Exemplo n.º 1
0
    def test_0010_render_report_xhtml(self):
        '''
        Render the report without PDF conversion
        '''
        UserReport = POOL.get('res.user', type='report')
        IRReport = POOL.get('ir.action.report')

        with Transaction().start(DB_NAME, USER, context=CONTEXT):
            self.setup_defaults()

            with Transaction().set_context(company=self.company.id):
                report_html, = IRReport.create([{
                    'name': 'HTML Report',
                    'model': 'res.user',
                    'report_name': 'res.user',
                    'report_content': buffer(
                        '<h1>Hello, {{records[0].name}}!</h1>'
                    ),
                    'extension': 'html',
                }])
                val = UserReport.execute([USER], {})
                self.assertEqual(val[0], u'html')
                self.assertEqual(
                    str(val[1]), '<h1>Hello, Administrator!</h1>'
                )
Exemplo n.º 2
0
    def _create_coa_minimal(self, company):
        """Create a minimal chart of accounts
        """
        AccountTemplate = POOL.get('account.account.template')
        Account = POOL.get('account.account')

        account_create_chart = POOL.get(
            'account.create_chart', type="wizard"
        )

        account_template, = AccountTemplate.search(
            [('parent', '=', None)]
        )

        session_id, _, _ = account_create_chart.create()
        create_chart = account_create_chart(session_id)
        create_chart.account.account_template = account_template
        create_chart.account.company = company
        create_chart.transition_create_account()

        receivable, = Account.search([
            ('kind', '=', 'receivable'),
            ('company', '=', company),
        ])
        payable, = Account.search([
            ('kind', '=', 'payable'),
            ('company', '=', company),
        ])
        create_chart.properties.company = company
        create_chart.properties.account_receivable = receivable
        create_chart.properties.account_payable = payable
        create_chart.transition_create_properties()
Exemplo n.º 3
0
    def test_0200_translation_clean(self):
        """
        Check if the cleaning of translations work
        """
        TranslationSet = POOL.get('ir.translation.set', type='wizard')
        TranslationClean = POOL.get('ir.translation.clean', type='wizard')
        IRTranslation = POOL.get('ir.translation')
        IRModule = POOL.get('ir.module.module')

        with Transaction().start(DB_NAME, USER, CONTEXT):
            # First create all the translations
            session_id, _, _ = TranslationSet.create()
            set_wizard = TranslationSet(session_id)
            set_wizard.transition_set_()

            # Uninstall nereid_test and there should be no translations
            # belonging to that module with type as nereid or
            # nereid_template
            nereid_test, = IRModule.search([('name', '=', 'nereid_test')])
            nereid_test.state = 'uninstalled'
            nereid_test.save()

            session_id, _, _ = TranslationClean.create()
            clean_wizard = TranslationClean(session_id)
            clean_wizard.transition_clean()

            count = IRTranslation.search([
                ('module', '=', 'nereid_test'),
                ('type', 'in', ('nereid', 'nereid_template'))
            ], count=True)
            self.assertEqual(count, 0)
Exemplo n.º 4
0
    def setUp(self):
        trytond.tests.test_tryton.install_module('nereid_s3')
        self.static_file = POOL.get('nereid.static.file')
        self.static_folder = POOL.get('nereid.static.folder')

        # Mock S3Connection
        self.s3_api_patcher = patch(
            'boto.s3.connection.S3Connection', autospec=True
        )
        PatchedS3 = self.s3_api_patcher.start()

        # Mock S3Key
        self.s3_key_patcher = patch(
            'boto.s3.key.Key', autospec=True
        )
        PatchedS3Key = self.s3_key_patcher.start()

        PatchedS3.return_value = connection.S3Connection('ABCD', '123XYZ')
        PatchedS3.return_value.get_bucket = lambda bucket_name: Bucket(
            PatchedS3.return_value, 'tryton-test-s3'
        )

        PatchedS3Key.return_value = Key(
            Bucket(PatchedS3.return_value, 'tryton-test-s3'), 'some key'
        )
        PatchedS3Key.return_value.key = "some key"
        PatchedS3Key.return_value.get_contents_as_string = lambda *a: 'testfile'
        PatchedS3Key.return_value.set_contents_from_string = \
            lambda value: 'testfile'
Exemplo n.º 5
0
    def test_0300_translation_update(self):
        """
        Check if the update does not break this functionality
        """
        TranslationSet = POOL.get('ir.translation.set', type='wizard')
        TranslationUpdate = POOL.get('ir.translation.update', type='wizard')
        IRTranslation = POOL.get('ir.translation')
        IRLanguage = POOL.get('ir.lang')

        with Transaction().start(DB_NAME, USER, CONTEXT):
            # First create all the translations
            session_id, _, _ = TranslationSet.create()
            set_wizard = TranslationSet(session_id)
            set_wizard.transition_set_()

            # set an additional language as translatable
            new_lang, = IRLanguage.search([
                ('translatable', '=', False)
            ], limit=1)
            new_lang.translatable = True
            new_lang.save()

            count_before = IRTranslation.search([], count=True)

            # Now update the translations
            session_id, _, _ = TranslationUpdate.create()
            update_wizard = TranslationUpdate(session_id)

            update_wizard.start.language = new_lang
            update_wizard.do_update(update_wizard.update.get_action())

            # check the count now
            count_after = IRTranslation.search([], count=True)
            self.assertEqual(count_after, count_before * 2)
Exemplo n.º 6
0
 def setUp(self):
     install_module('test')
     self.one2many = POOL.get('test.copy.one2many')
     self.one2many_target = POOL.get('test.copy.one2many.target')
     self.one2many_reference = POOL.get('test.copy.one2many_reference')
     self.one2many_reference_target = \
         POOL.get('test.copy.one2many_reference.target')
Exemplo n.º 7
0
    def test_0090_import_sale_order_with_bundle_product_check_duplicate(self):
        """
        Tests import of sale order with bundle product using magento data
        This tests that the duplication of BoMs doesnot happen
        """
        Sale = POOL.get('sale.sale')
        ProductTemplate = POOL.get('product.template')
        Category = POOL.get('product.category')
        MagentoOrderState = POOL.get('magento.order_state')

        with Transaction().start(DB_NAME, USER, CONTEXT):
            self.setup_defaults()
            with Transaction().set_context({
                'magento_instance': self.instance1.id,
                'magento_store_view': self.store_view.id,
                'magento_website': self.website1.id,
            }):

                MagentoOrderState.create_all_using_magento_data(
                    load_json('order-states', 'all'),
                )

                category_tree = load_json('categories', 'category_tree')
                Category.create_tree_using_magento_data(category_tree)

                order_data = load_json('orders', '300000001')

                with patch(
                        'magento.Customer', mock_customer_api(), create=True):
                    self.Party.find_or_create_using_magento_id(
                        order_data['customer_id']
                    )

                with Transaction().set_context({'company': self.company.id}):
                    # Create sale order using magento data
                    with patch(
                        'magento.Product', mock_product_api(), create=True
                    ):
                        Sale.find_or_create_using_magento_data(order_data)

                # There should be a BoM for the bundle product
                product_template = \
                    ProductTemplate.find_or_create_using_magento_id(158)
                product = product_template.products[0]
                self.assertTrue(len(product.boms), 1)
                self.assertTrue(len(product.boms[0].bom.inputs), 2)

                order_data = load_json('orders', '300000001-a')

                # Create sale order using magento data
                with patch('magento.Product', mock_product_api(), create=True):
                    Sale.find_or_create_using_magento_data(order_data)

                # There should be a BoM for the bundle product
                product_template = \
                    ProductTemplate.find_or_create_using_magento_id(
                        158
                    )
                self.assertEqual(len(product.boms), 1)
                self.assertEqual(len(product.boms[0].bom.inputs), 2)
Exemplo n.º 8
0
    def test_0400_translation_export(self):
        """
        Export the translations and test
        """
        TranslationSet = POOL.get('ir.translation.set', type='wizard')
        TranslationUpdate = POOL.get('ir.translation.update', type='wizard')
        IRTranslation = POOL.get('ir.translation')
        IRLanguage = POOL.get('ir.lang')

        with Transaction().start(DB_NAME, USER, CONTEXT):
            # First create all the translations
            session_id, _, _ = TranslationSet.create()
            set_wizard = TranslationSet(session_id)
            set_wizard.transition_set_()

            # set an additional language as translatable
            new_lang, = IRLanguage.search([
                ('translatable', '=', False)
            ], limit=1)
            new_lang.translatable = True
            new_lang.save()

            # Now update the translations
            session_id, _, _ = TranslationUpdate.create()
            update_wizard = TranslationUpdate(session_id)

            update_wizard.start.language = new_lang
            update_wizard.do_update(update_wizard.update.get_action())

            # TODO: Check the contents of the po file
            IRTranslation.translation_export(new_lang.code, 'nereid_test')
            IRTranslation.translation_export(new_lang.code, 'nereid')
Exemplo n.º 9
0
    def test0030_get_variant_images(self):
        """
        Test to get variant images.

        If boolean field use_template_images is true return images
        of product template else return images of variant
        """
        Product = POOL.get('product.product')
        StaticFolder = POOL.get("nereid.static.folder")
        StaticFile = POOL.get("nereid.static.file")

        with Transaction().start(DB_NAME, USER, CONTEXT):
            self.setup_defaults()

            folder, = StaticFolder.create([{
                'name': 'Test'
            }])
            file_buffer = buffer('test-content')
            file = StaticFile.create([{
                'name': 'test.png',
                'folder': folder.id,
                'file_binary': file_buffer
            }])[0]

            file1 = StaticFile.create([{
                'name': 'test1.png',
                'folder': folder.id,
                'file_binary': file_buffer
            }])[0]

            uom, = self.Uom.search([], limit=1)

            # creating product template
            product_template, = self.Template.create([{
                'name': 'test template',
                'category': self.category.id,
                'type': 'goods',
                'list_price': Decimal('10'),
                'cost_price': Decimal('5'),
                'default_uom': uom.id,
                'description': 'Description of template',
                'media': [('create', [{
                    'static_file': file.id,
                }])],
                'products': [('create', self.Template.default_products())]
            }])

            product, = product_template.products

            Product.write([product], {
                'media': [('create', [{
                    'static_file': file1.id,
                }])]
            })

            self.assertEqual(product.get_images()[0].id, file.id)
            Product.write([product], {
                'use_template_images': False,
            })
            self.assertEqual(product.get_images()[0].id, file1.id)
Exemplo n.º 10
0
 def setUp(self):
     super(CompanyTestCase, self).setUp()
     self.party = POOL.get('party.party')
     self.company = POOL.get('company.company')
     self.employee = POOL.get('company.employee')
     self.currency = POOL.get('currency.currency')
     self.user = POOL.get('res.user')
Exemplo n.º 11
0
 def setUp(self):
     trytond.tests.test_tryton.install_module('company')
     self.party = POOL.get('party.party')
     self.company = POOL.get('company.company')
     self.employee = POOL.get('company.employee')
     self.currency = POOL.get('currency.currency')
     self.user = POOL.get('res.user')
Exemplo n.º 12
0
    def test_0080_export_product_stock_information(self):
        """
        This test checks if the method to call for updation of product
        stock info does not break anywhere in between.
        This method does not check the API calls
        """
        Product = POOL.get('product.product')
        Category = POOL.get('product.category')

        with Transaction().start(DB_NAME, USER, CONTEXT):
            self.setup_defaults()

            with Transaction().set_context({
                'current_channel': self.channel1.id,
                'company': self.company.id,
            }):

                category_data = load_json('categories', '17')

                Category.create_using_magento_data(category_data)

                product_data = load_json('products', '135')
                Product.find_or_create_using_magento_data(
                    product_data
                )

                with patch(
                    'magento.Inventory', mock_inventory_api(), create=True
                ):
                    self.channel1.export_inventory()
Exemplo n.º 13
0
    def setUp(self):
        super(BaseTestCheckout, self).setUp()
        trytond.tests.test_tryton.install_module("nereid_shipping")
        trytond.tests.test_tryton.install_module("shipping_ups")

        self.Carrier = POOL.get("carrier")
        self.Category = POOL.get("product.category")
        self.Account = POOL.get("account.account")
        self.ProductTemplate = POOL.get("product.template")
        self.UPSService = POOL.get("ups.service")

        self.templates.update(
            {
                "checkout/signin.jinja": "{{form.errors|safe}}",
                "checkout/signin-email-in-use.jinja": "{{email}} in use",
                "checkout/shipping_address.jinja": "{{address_form.errors|safe}}",
                "checkout/billing_address.jinja": "{{address_form.errors|safe}}",
                "checkout/delivery_method.jinja": "{{delivery_rates|map(attribute=4)|list|tojson|safe}}",
                "checkout/payment_method.jinja": """[
                {{payment_form.errors|safe}},
                {{credit_card_form.errors|safe}},
            ]""",
                "emails/sale-confirmation-text.jinja": " ",
                "emails/sale-confirmation-html.jinja": " ",
                "checkout.jinja": "{{form.errors|safe}}",
                "sale.jinja": " ",
                "sales.jinja": """{{request.args.get('filter_by')}}
                {% for sale in sales %}#{{sale.id}}{% endfor %}
            """,
            }
        )

        # Patch SMTP Lib
        self.smtplib_patcher = patch("smtplib.SMTP")
        self.PatchedSMTP = self.smtplib_patcher.start()
Exemplo n.º 14
0
    def test0030_menuitem(self):
        '''
        Test create menuitem for products
        '''
        self.Product = POOL.get('product.product')
        self.Template = POOL.get('product.template')
        with Transaction().start(DB_NAME, USER, context=CONTEXT):
            app = self.get_app()
            self.setup_defaults()
            uom, = self.Uom.search([], limit=1)

            template, = self.Template.create([{
                'name': 'TestProduct',
                'type': 'goods',
                'list_price': Decimal('100'),
                'cost_price': Decimal('100'),
                'default_uom': uom.id,
            }])
            product, = self.Product.create([{
                'template': template.id,
                'displayed_on_eshop': True,
                'uri': 'test-product',
            }])

            with app.test_request_context('/'):
                rv = product.get_menu_item(max_depth=10)

            self.assertEqual(rv['title'], product.name)
Exemplo n.º 15
0
    def test_0100_product_images(self):
        """
        Test for adding product images
        """
        Product = POOL.get('product.product')
        StaticFolder = POOL.get("nereid.static.folder")
        StaticFile = POOL.get("nereid.static.file")
        Media = POOL.get('product.media')

        with Transaction().start(DB_NAME, USER, CONTEXT):
            self.setup_defaults()
            self.create_test_products()

            folder, = StaticFolder.create([{
                'name': 'Test'
            }])
            file_buffer = buffer('test-content')
            file, = StaticFile.create([{
                'name': 'test.png',
                'folder': folder.id,
                'file_binary': file_buffer
            }])

            product, = Product.search([], limit=1)

            Media.create([{
                'product': product.id,
                'template': product.template.id,
                'static_file': file.id,
            }])

            app = self.get_app()
            with app.test_request_context('/'):
                home_template = render_template('home.jinja', product=product)
                self.assertTrue(file.name in home_template)
Exemplo n.º 16
0
    def _create_product_template(
        self, name, vlist, uri, uom=u'Unit', displayed_on_eshop=True
    ):
        """
        Create a product template with products and return its ID

        :param name: Name of the product
        :param vlist: List of dictionaries of values to create
        :param uri: uri of product template
        :param uom: Note it is the name of UOM (not symbol or code)
        :param displayed_on_eshop: Boolean field to display product
                                   on shop or not
        """
        ProductTemplate = POOL.get('product.template')
        Uom = POOL.get('product.uom')

        for values in vlist:
            values['name'] = name
            values['default_uom'], = Uom.search([('name', '=', uom)], limit=1)
            values['products'] = [
                ('create', [{
                    'uri': uri,
                    'displayed_on_eshop': displayed_on_eshop,
                }])
            ]

        return ProductTemplate.create(vlist)
    def _create_fiscal_year(self, date=None, company=None):
        """
        Creates a fiscal year and requried sequences
        """
        FiscalYear = POOL.get('account.fiscalyear')
        Sequence = POOL.get('ir.sequence')
        Company = POOL.get('company.company')

        if date is None:
            date = datetime.date.today()

        if company is None:
            company, = Company.search([], limit=1)

        fiscal_year, = FiscalYear.create([{
            'name': '%s' % date.year,
            'start_date': date + relativedelta(month=1, day=1),
            'end_date': date + relativedelta(month=12, day=31),
            'company': company,
            'post_move_sequence': Sequence.create([{
                'name': '%s' % date.year,
                'code': 'account.move',
                'company': company,
            }])[0],
        }])
        FiscalYear.create_period([fiscal_year])
        return fiscal_year
Exemplo n.º 18
0
    def test_0050_import_grouped_product(self):
        """
        Test the import of a grouped product using magento data
        """
        Category = POOL.get('product.category')
        Product = POOL.get('product.product')

        with Transaction().start(DB_NAME, USER, CONTEXT) as txn:
            self.setup_defaults()
            category_data = load_json('categories', 22)
            product_data = load_json('products', 54)
            with txn.set_context({
                'current_channel': self.channel1.id,
                'company': self.company.id,
            }):
                Category.create_using_magento_data(category_data)
                product = Product.find_or_create_using_magento_data(
                    product_data
                )
                self.assertEqual(
                    product.category.magento_ids[0].magento_id, 22
                )
                self.assertEqual(
                    product.channel_listings[0].magento_product_type,
                    'grouped'
                )
Exemplo n.º 19
0
    def test_0080_import_sale_order_with_bundle_product(self):
        """
        Tests import of sale order with bundle product using magento data
        """
        Sale = POOL.get('sale.sale')
        Category = POOL.get('product.category')

        with Transaction().start(DB_NAME, USER, CONTEXT):
            self.setup_defaults()

            with Transaction().set_context({
                'current_channel': self.channel1.id,
            }):

                order_states_list = load_json('order-states', 'all')
                for code, name in order_states_list.iteritems():
                    self.channel1.create_order_state(code, name)

                category_tree = load_json('categories', 'category_tree')
                Category.create_tree_using_magento_data(category_tree)

                orders = Sale.search([])
                self.assertEqual(len(orders), 0)

                order_data = load_json('orders', '300000001')

                with patch(
                        'magento.Customer', mock_customer_api(), create=True):
                    self.Party.find_or_create_using_magento_id(
                        order_data['customer_id']
                    )

                with Transaction().set_context(company=self.company):
                    # Create sale order using magento data
                    with patch(
                        'magento.Product', mock_product_api(), create=True
                    ):
                        order = Sale.find_or_create_using_magento_data(
                            order_data
                        )

                self.assertEqual(order.state, 'confirmed')

                orders = Sale.search([])
                self.assertEqual(len(orders), 1)

                # Item lines + shipping line should be equal to lines on tryton
                self.assertEqual(len(order.lines), 2)

                self.assertEqual(
                    order.total_amount, Decimal(order_data['base_grand_total'])
                )

                # There should be a BoM for the bundle product
                product = self.channel1.import_product('VGN-TXN27N-BW')

                self.assertEqual(len(product.boms), 1)
                self.assertEqual(
                    len(product.boms[0].bom.inputs), 2
                )
Exemplo n.º 20
0
    def setUp(self):
        super(BaseTestCheckout, self).setUp()
        trytond.tests.test_tryton.install_module('nereid_checkout')

        self.Journal = POOL.get('account.journal')
        self.Category = POOL.get('product.category')
        self.Account = POOL.get('account.account')

        self.templates.update({
            'checkout/signin.jinja': '{{form.errors|safe}}',
            'checkout/signin-email-in-use.jinja': '{{email}} in use',
            'checkout/shipping_address.jinja': '{{address_form.errors|safe}}',
            'checkout/billing_address.jinja': '{{address_form.errors|safe}}',
            'checkout/payment_method.jinja': '''[
                {{payment_form.errors|safe}},
                {{credit_card_form.errors|safe}},
            ]''',
            'emails/sale-confirmation-text.jinja': ' ',
            'emails/sale-confirmation-html.jinja': ' ',
            'checkout.jinja': '{{form.errors|safe}}',
            'sale.jinja': ' ',
            'sales.jinja': '''{{request.args.get('filter_by')}}
                {% for sale in sales %}#{{sale.id}}{% endfor %}
            '''
        })

        # Patch SMTP Lib
        self.smtplib_patcher = patch('smtplib.SMTP')
        self.PatchedSMTP = self.smtplib_patcher.start()
Exemplo n.º 21
0
    def _create_auth_net_gateway_for_site(self):
        """
        A helper function that creates the authorize.net gateway and assigns
        it to the websites.
        """
        PaymentGateway = POOL.get('payment_gateway.gateway')
        NereidWebsite = POOL.get('nereid.website')
        Journal = POOL.get('account.journal')

        cash_journal, = Journal.search([
            ('name', '=', 'Cash')
        ])

        gateway = PaymentGateway(
            name='Authorize.net',
            journal=cash_journal,
            provider='authorize_net',
            method='credit_card',
            authorize_net_login='******',
            authorize_net_transaction_key='32jF65cTxja88ZA2',
            test=True
        )
        gateway.save()

        websites = NereidWebsite.search([])
        NereidWebsite.write(websites, {
            'accept_credit_card': True,
            'save_payment_profile': True,
            'credit_card_gateway': gateway.id,
        })
        return gateway
Exemplo n.º 22
0
 def setUp(self):
     trytond.tests.test_tryton.install_module('product')
     self.uom = POOL.get('product.uom')
     self.uom_category = POOL.get('product.uom.category')
     self.template = POOL.get('product.template')
     self.product = POOL.get('product.product')
     self.category = POOL.get('product.category')
    def _create_fiscal_year(self, date=None, company=None):
        """
        Creates a fiscal year and requried sequences
        """
        Sequence = POOL.get("ir.sequence")
        SequenceStrict = POOL.get("ir.sequence.strict")

        if date is None:
            date = datetime.date.today()

        if company is None:
            company, = self.Company.search([], limit=1)

        invoice_sequence, = SequenceStrict.create(
            [{"name": "%s" % date.year, "code": "account.invoice", "company": company}]
        )
        fiscal_year, = self.FiscalYear.create(
            [
                {
                    "name": "%s" % date.year,
                    "start_date": date + relativedelta(month=1, day=1),
                    "end_date": date + relativedelta(month=12, day=31),
                    "company": company,
                    "post_move_sequence": Sequence.create(
                        [{"name": "%s" % date.year, "code": "account.move", "company": company}]
                    )[0],
                    "out_invoice_sequence": invoice_sequence,
                    "in_invoice_sequence": invoice_sequence,
                    "out_credit_note_sequence": invoice_sequence,
                    "in_credit_note_sequence": invoice_sequence,
                }
            ]
        )
        self.FiscalYear.create_period([fiscal_year])
        return fiscal_year
 def setUp(self):
     trytond.tests.test_tryton.install_module('elastic_search')
     self.IndexBacklog = POOL.get('elasticsearch.index_backlog')
     self.DocumentType = POOL.get('elasticsearch.document.type')
     self.User = POOL.get('res.user')
     self.Model = POOL.get('ir.model')
     self.Trigger = POOL.get('ir.trigger')
Exemplo n.º 25
0
    def test_0020_render_unicode(self):
        '''
        Render the report without PDF conversion but having unicode template
        '''
        UserReport = POOL.get('res.user', type='report')
        IRReport = POOL.get('ir.action.report')

        with Transaction().start(DB_NAME, USER, context=CONTEXT):
            self.setup_defaults()

            with Transaction().set_context(company=self.company.id):
                report_html, = IRReport.create([{
                    'name': 'HTML Report',
                    'model': 'res.user',
                    'report_name': 'res.user',
                    'report_content': buffer(
                        "<h1>Héllø, {{data['name']}}!</h1>"
                    ),
                    'extension': 'html',
                }])

                val = UserReport.execute([USER], {'name': u'Cédric'})
                self.assertEqual(val[0], u'html')
                self.assertEqual(
                    str(val[1]), '<h1>Héllø, Cédric!</h1>'
                )
    def _create_fiscal_year(self, date=None, company=None):
        """
        Creates a fiscal year and requried sequences
        """
        Sequence = POOL.get('ir.sequence')
        SequenceStrict = POOL.get('ir.sequence.strict')

        if date is None:
            date = datetime.date.today()

        if company is None:
            company, = self.Company.search([], limit=1)

        invoice_sequence, = SequenceStrict.create([{
            'name': '%s' % date.year,
            'code': 'account.invoice',
            'company': company,
        }])
        fiscal_year, = self.FiscalYear.create([{
            'name': '%s' % date.year,
            'start_date': date + relativedelta(month=1, day=1),
            'end_date': date + relativedelta(month=12, day=31),
            'company': company,
            'post_move_sequence': Sequence.create([{
                'name': '%s' % date.year,
                'code': 'account.move',
                'company': company,
            }])[0],
            'out_invoice_sequence': invoice_sequence,
            'in_invoice_sequence': invoice_sequence,
            'out_credit_note_sequence': invoice_sequence,
            'in_credit_note_sequence': invoice_sequence,
        }])
        self.FiscalYear.create_period([fiscal_year])
        return fiscal_year
Exemplo n.º 27
0
    def test_0050_import_grouped_product(self):
        """
        Test the import of a grouped product using magento data
        """
        Category = POOL.get('product.category')
        ProductTemplate = POOL.get('product.template')

        with Transaction().start(DB_NAME, USER, CONTEXT) as txn:
            self.setup_defaults()
            category_data = load_json('categories', 22)
            product_data = load_json('products', 54)
            with txn.set_context({
                'magento_instance': self.instance1,
                'magento_website': self.website1,
                'company': self.company,
            }):
                Category.create_using_magento_data(category_data)
                template = ProductTemplate.find_or_create_using_magento_data(
                    product_data
                )
                self.assertEqual(
                    template.category.magento_ids[0].magento_id, 22
                )
                self.assertEqual(
                    template.magento_product_type, 'grouped'
                )
Exemplo n.º 28
0
    def _create_cheque_payment_method(self):
        """
        A helper function that creates the cheque gateway and assigns
        it to the websites.
        """
        PaymentGateway = POOL.get('payment_gateway.gateway')
        NereidWebsite = POOL.get('nereid.website')
        PaymentMethod = POOL.get('nereid.website.payment_method')
        Journal = POOL.get('account.journal')

        cash_journal, = Journal.search([
            ('name', '=', 'Cash')
        ])

        gateway = PaymentGateway(
            name='Offline Payment Methods',
            journal=cash_journal,
            provider='self',
            method='manual',
        )
        gateway.save()

        website, = NereidWebsite.search([])

        payment_method = PaymentMethod(
            name='Cheque',
            gateway=gateway,
            website=website
        )
        payment_method.save()
        return payment_method
Exemplo n.º 29
0
    def test_0100_template_trans_tag_with_expr(self):
        """
        Test for
        {% trans user=user.username %}Hello {{ user }}!{% endtrans %} tag
        """
        TranslationSet = POOL.get('ir.translation.set', type='wizard')
        IRTranslation = POOL.get('ir.translation')

        with Transaction().start(DB_NAME, USER, CONTEXT):
            session_id, _, _ = TranslationSet.create()
            set_wizard = TranslationSet(session_id)

            # Set the nereid_template translations alone
            set_wizard.set_nereid_template()

            # XXX: See how {{ user }} changed to %(user)s
            translation, = IRTranslation.search([
                ('type', '=', 'nereid_template'),
                ('module', '=', 'nereid_test'),
                ('src', '=', 'Hello %(name)s!')
            ])
            self.assertEqual(
                translation.comments, 'Translation with an expression'
            )
            self.assertEqual(translation.res_id, 26)
Exemplo n.º 30
0
    def test_0080_template_ngettext(self):
        """
        Test for ngettext
        """
        TranslationSet = POOL.get('ir.translation.set', type='wizard')
        IRTranslation = POOL.get('ir.translation')

        with Transaction().start(DB_NAME, USER, CONTEXT):
            session_id, _, _ = TranslationSet.create()
            set_wizard = TranslationSet(session_id)

            # Set the nereid_template translations alone
            set_wizard.set_nereid_template()

            translation, = IRTranslation.search([
                ('type', '=', 'nereid_template'),
                ('module', '=', 'nereid_test'),
                ('src', '=', '%(num)d apple')
            ])
            self.assertEqual(translation.res_id, 20)

            # Look for plural
            translation, = IRTranslation.search([
                ('type', '=', 'nereid_template'),
                ('module', '=', 'nereid_test'),
                ('src', '=', '%(num)d apples')
            ])
            self.assertEqual(translation.res_id, 20)
    def test_0060_make_tree_crumbs(self):
        """
        Test to get breadcrumbs on node template
        """
        Node = POOL.get('product.tree_node')

        self.setup_defaults()
        app = self.get_app()

        parent_node, = Node.create([{
            'name': 'Node1',
            'type_': 'catalog',
            'slug': 'node1',
            'parent': self.default_node,
        }])

        child_node, = Node.create([{
            'name': 'Node2',
            'type_': 'catalog',
            'slug': 'node2',
            'parent': parent_node,
        }])

        with app.test_client() as c:
            rv = c.get('nodes/%d/node2' % child_node.id)
            self.assertEqual(
                rv.data[3:], "Home, root, Node1, Node2"
            )
Exemplo n.º 32
0
    def test0010_import_product(self):
        """
        Test the import of simple product using eBay Data
        """
        Product = POOL.get('product.product')

        with Transaction().start(DB_NAME, USER, CONTEXT) as txn:
            self.setup_defaults()

            with txn.set_context({
                    'current_channel': self.ebay_channel.id,
                    'company': self.company,
            }):

                products_before_import = Product.search([], count=True)

                product_data = load_json('products', '110162956809')
                product = Product.create_using_ebay_data(product_data)
                self.assertEqual(product.template.name, 'Iphone')

                products_after_import = Product.search([], count=True)
                self.assertTrue(products_after_import > products_before_import)

                self.assertEqual(
                    product, self.ebay_channel.import_product('110162956809'))
Exemplo n.º 33
0
    def test_0020_kwargs(self):
        """
        Test if kwargs work
        """
        IRTranslation = POOL.get('ir.translation')

        s = _("Hi %(name)s", name="Sharoon")
        self.assertEqual(s, u"Hi Sharoon")

        # install translations
        self.set_translations()
        self.update_translations('fr_FR')

        # without setting a tranlsation looking for it gives en_US
        with Transaction().set_context(language="fr_FR"):
            self.assertEqual(s, u'Hi Sharoon')

        # write a translation for it
        translation, = IRTranslation.search([('module', '=', 'nereid'),
                                             ('src', '=', 'Hi %(name)s'),
                                             ('lang', '=', 'fr_FR')])
        translation.value = 'Bonjour %(name)s'
        translation.save()

        with Transaction().set_context(language="fr_FR"):
            self.assertEqual(s, u'Bonjour Sharoon')
Exemplo n.º 34
0
    def test_0210_regd_alternate_payment(self):
        "Regd User - Alternate Payment Method"
        self.setup_defaults()
        app = self.get_app()

        Sale = POOL.get('sale.sale')

        # Define a new payment gateway
        cheque_method = self._create_cheque_payment_method()

        with app.test_client() as c:
            self._create_regd_user_order(c, 10)

            # Try to pay using credit card
            rv = c.post('/checkout/payment',
                        data={'alternate_payment_method': cheque_method.id})
            self.assertEqual(rv.status_code, 302)
            self.assertTrue('/order/' in rv.location)

            sale, = Sale.search([('state', '=', 'confirmed')])

            # Process sale with payments
            self._process_sale_by_completing_payments([sale])

            payment_transaction, = sale.gateway_transactions
            self.assertEqual(payment_transaction.amount, sale.total_amount)
            self.assertEqual(payment_transaction.state, 'completed')
    def test_0220_test_dummy_profile_add(self):
        """
        Test dummy gateway profile addition
        """
        AddPaymentProfileWizard = POOL.get('party.party.payment_profile.add',
                                           type='wizard')
        self.setup_defaults()

        with Transaction().set_context(company=self.company.id,
                                       use_dummy=True):

            gateway, = self.PaymentGateway.create([{
                'name':
                'Dummy Gateway',
                'journal':
                self.cash_journal.id,
                'provider':
                'dummy',
                'method':
                'credit_card',
            }])

            # create a profile
            profile_wiz = AddPaymentProfileWizard(
                AddPaymentProfileWizard.create()[0])
            profile_wiz.card_info.party = self.party.id
            profile_wiz.card_info.address = self.party.addresses[0].id
            profile_wiz.card_info.provider = gateway.provider
            profile_wiz.card_info.gateway = gateway
            profile_wiz.card_info.owner = self.party.name
            profile_wiz.card_info.number = '4111111111111111'
            profile_wiz.card_info.expiry_month = '11'
            profile_wiz.card_info.expiry_year = '2018'
            profile_wiz.card_info.csc = '353'
            profile_wiz.transition_add()
Exemplo n.º 36
0
    def test_0010_create_amazon_account(self):
        """
        Create amazon mws account
        """
        Location = POOL.get('stock.location')

        with Transaction().start(DB_NAME, USER, CONTEXT):
            self.setup_defaults()

            warehouse, = Location.search([('type', '=', 'warehouse')], limit=1)

            account = self.MWSAccount.create([{
                'merchant_id':
                '1234',
                'marketplace_id':
                '3456',
                'access_key':
                'AWS1',
                'secret_key':
                'S013',
                'warehouse':
                warehouse.id,
                'company':
                self.company.id,
                'default_account_revenue':
                self.get_account_by_kind('revenue'),
                'default_account_expense':
                self.get_account_by_kind('expense'),
            }])

            self.assert_(account)
    def test_0010_test_add_payment_profile(self):
        """
        Test adding payment profile to a Party
        """
        self.setup_defaults()

        ProfileWizard = POOL.get('party.party.payment_profile.add',
                                 type="wizard")

        profile_wizard = ProfileWizard(ProfileWizard.create()[0])
        profile_wizard.card_info.owner = self.party2.name
        profile_wizard.card_info.number = self.card_data1.number
        profile_wizard.card_info.expiry_month = self.card_data1.expiry_month
        profile_wizard.card_info.expiry_year = self.card_data1.expiry_year
        profile_wizard.card_info.csc = self.card_data1.csc
        profile_wizard.card_info.gateway = self.auth_net_gateway
        profile_wizard.card_info.provider = self.auth_net_gateway.provider
        profile_wizard.card_info.address = self.party2.addresses[0]
        profile_wizard.card_info.party = self.party2

        with Transaction().set_context(return_profile=True):
            profile = profile_wizard.transition_add()

        self.assertEqual(profile.party.id, self.party2.id)
        self.assertEqual(profile.gateway, self.auth_net_gateway)
        self.assertEqual(profile.last_4_digits, self.card_data1.number[-4:])
        self.assertEqual(profile.expiry_month, self.card_data1.expiry_month)
        self.assertEqual(profile.expiry_year, self.card_data1.expiry_year)
        self.assertIsNotNone(profile.authorize_profile_id)
Exemplo n.º 38
0
    def test_0090_check_channel_exception(self):
        """
        Check if channel exception is being created
        """
        ChannelException = POOL.get('channel.exception')

        with Transaction().start(DB_NAME, USER, context=CONTEXT):
            self.setup_defaults()

            sale = self.create_sale(1, self.channel1)

            self.assertFalse(sale.has_channel_exception)

            channel_exception, = ChannelException.create([{
                'origin': '%s,%s' % (sale.__name__, sale.id),
                'log': 'Sale has exception',
                'channel': sale.channel.id,
            }])

            self.assert_(channel_exception)

            self.assertTrue(sale.has_channel_exception)

            # Mark exception as resolved
            channel_exception.is_resolved = True
            channel_exception.save()

            self.assertFalse(sale.has_channel_exception)
    def setUp(self):
        """
        Set up data used in the tests.
        """

        self.Currency = POOL.get('currency.currency')
        self.Company = POOL.get('company.company')
        self.Party = POOL.get('party.party')
        self.User = POOL.get('res.user')
        self.Journal = POOL.get('account.journal')
        self.PaymentGateway = POOL.get('payment_gateway.gateway')
        self.PaymentTransaction = POOL.get('payment_gateway.transaction')
        self.AccountMove = POOL.get('account.move')
        self.PaymentProfile = POOL.get('party.payment_profile')
        self.UseCardView = POOL.get(
            'payment_gateway.transaction.use_card.view')
Exemplo n.º 40
0
    def test_0330_registered_user_payment_using_payment_profile(self):
        """
        ===================================
        Total Sale Amount       |   $100
        Payment Authorize On:   | 'manual'
        Payment Capture On:     | 'sale_process'
        ===================================
        Total Payment Lines     |     1
        Payment 1               |   $100
        ===================================
        """
        Sale = POOL.get('sale.sale')

        self.setup_defaults()

        app = self.get_app()

        auth_gateway = self._create_auth_net_gateway_for_site()

        with app.test_client() as c:
            self._create_regd_user_order(c, 10)

            sale, = Sale.search([], limit=1)

            self.assertEqual(sale.total_amount, Decimal('100'))
            self.assertEqual(sale.payment_total, Decimal('0'))
            self.assertEqual(sale.payment_collected, Decimal('0'))
            self.assertEqual(sale.payment_captured, Decimal('0'))
            self.assertEqual(sale.payment_available, Decimal('0'))
            self.assertEqual(sale.payment_authorized, Decimal('0'))

            gateway = self._create_auth_net_gateway_for_site()

            payment_profile = self.create_payment_profile(sale.party, gateway)

            rv = c.post('/checkout/payment',
                        data={'payment_profile': payment_profile.id})
            self.assertEqual(rv.status_code, 302)

            self.assertEqual(sale.state, 'confirmed')
            self.assertEqual(len(sale.payments), 1)

            sale_payment, = sale.payments
            self.assertEqual(sale_payment.method, auth_gateway.method)

            self.assertEqual(sale.payment_total, Decimal('100'))
            self.assertEqual(sale.payment_available, Decimal('100'))
            self.assertEqual(sale.payment_collected, Decimal('0'))
            self.assertEqual(sale.payment_captured, Decimal('0'))
            self.assertEqual(sale.payment_authorized, Decimal('0'))

            with Transaction().set_context(company=self.company.id):
                self.Sale.process([sale])
                self.Sale.process_all_pending_payments()

            self.assertEqual(sale.payment_total, Decimal('100'))
            self.assertEqual(sale.payment_available, Decimal('0'))
            self.assertEqual(sale.payment_collected, Decimal('100'))
            self.assertEqual(sale.payment_captured, Decimal('100'))
            self.assertEqual(sale.payment_authorized, Decimal('0'))
Exemplo n.º 41
0
    def test0060_ordered_search_same_timestamp(self):
        'Test ordered search  with same timestamp'
        History = POOL.get('test.history')
        order = [('value', 'ASC')]

        with Transaction().start(DB_NAME, USER,
                                 context=CONTEXT) as transaction:
            history = History(value=1)
            history.save()
            first_stamp = history.create_date
            history.value = 4
            history.save()
            second_stamp = history.write_date

            self.assertEqual(first_stamp, second_stamp)
            transaction.cursor.commit()

        results = [
            (second_stamp, [history], [4]),
            (datetime.datetime.now(), [history], [4]),
            (datetime.datetime.max, [history], [4]),
        ]

        with Transaction().start(DB_NAME, USER, context=CONTEXT):
            for timestamp, instances, values in results:
                with Transaction().set_context(_datetime=timestamp,
                                               last_test=True):
                    records = History.search([], order=order)
                    self.assertEqual(records, instances)
                    self.assertEqual([x.value for x in records], values)
Exemplo n.º 42
0
    def test0010_create_party(self):
        """
        Tests if customers imported from magento is created as party
        in tryton
        """
        MagentoParty = POOL.get('magento.website.party')

        with Transaction().start(DB_NAME, USER, CONTEXT):

            self.setup_defaults()

            Transaction().context.update({'magento_website': self.website1.id})
            magento_data = load_json('customers', '1')

            customer_name = u' '.join(
                [magento_data['firstname'], magento_data['lastname']])

            self.assertFalse(self.Party.search([('name', '=', customer_name)]))

            parties = MagentoParty.search([])
            self.assertEqual(len(parties), 0)

            # Create party
            party = self.Party.find_or_create_using_magento_data(magento_data)
            self.assert_(party)

            self.assertTrue(self.Party.search([('name', '=', customer_name)]))
            self.assertTrue(len(party.contact_mechanisms), 1)
            self.assertTrue(party.contact_mechanisms[0].email)
            parties = MagentoParty.search([])

            self.assertEqual(len(parties), 1)
Exemplo n.º 43
0
    def test0041restore_history_before(self):
        'Test restore history before'
        History = POOL.get('test.history')

        with Transaction().start(DB_NAME, USER,
                                 context=CONTEXT) as transaction:
            history = History(value=1)
            history.save()
            history_id = history.id

            transaction.cursor.commit()

        with Transaction().start(DB_NAME, USER,
                                 context=CONTEXT) as transaction:
            history = History(history_id)
            history.value = 2
            history.save()
            second = history.write_date

            transaction.cursor.commit()

        with Transaction().start(DB_NAME, USER,
                                 context=CONTEXT) as transaction:
            history = History(history_id)
            history.value = 3
            history.save()

            transaction.cursor.commit()

        with Transaction().start(DB_NAME, USER, context=CONTEXT):
            History.restore_history_before([history_id], second)
            history = History(history_id)
            self.assertEqual(history.value, 1)
Exemplo n.º 44
0
    def test_0030_check_prestashop_exception_order_total(self):
        """
        Check if exception is created when order total does not match
        """
        ChannelException = POOL.get('channel.exception')

        with Transaction().start(DB_NAME, USER, context=CONTEXT):
            # Call method to setup defaults
            self.setup_defaults()

            with Transaction().set_context(
                    self.User.get_preferences(context_only=True),
                    current_channel=self.channel.id,
                    ps_test=True,
            ):
                self.setup_channels()

                order_data = get_objectified_xml('orders', 1)

                order_data.total_paid_tax_excl = 100

                self.assertFalse(ChannelException.search([]))

                sale = self.Sale.find_or_create_using_ps_data(order_data)

                self.assertNotEqual(sale.total_amount,
                                    order_data.total_paid_tax_excl)

                self.assertTrue(sale.has_channel_exception)

                self.assertTrue(ChannelException.search([]))

                self.assertNotEqual(sale.state, 'done')
    def test_0115_check_processing_of_sale(self):
        """
        Check if channel exception is being created
        """
        ChannelException = POOL.get('channel.exception')

        self.setup_defaults()

        sale = self.create_sale(1, self.channel1)

        self.assertFalse(sale.has_channel_exception)

        channel_exception, = ChannelException.create([{
            'origin': '%s,%s' % (sale.__name__, sale.id),
            'log': 'Sale has exception',
            'channel': sale.channel.id,
        }])

        self.assert_(channel_exception)

        self.assertTrue(sale.has_channel_exception)

        # sale should not be confirmed as long as channel exception
        # is not resolved and error should be raised for it
        with self.assertRaises(UserError):
            self.Sale.confirm([sale])

        # Mark exception as resolved
        channel_exception.is_resolved = True
        channel_exception.save()

        self.assertFalse(sale.has_channel_exception)

        # Exception error should not be raised after it is resolved
        self.Sale.confirm([sale])
Exemplo n.º 46
0
    def test0045restore_history_same_timestamp(self):
        'Test restore history with same timestamp'
        History = POOL.get('test.history')

        with Transaction().start(DB_NAME, USER,
                                 context=CONTEXT) as transaction:
            history = History(value=1)
            history.save()
            history_id = history.id
            first = history.create_date
            history.value = 2
            history.save()
            second = history.create_date

            self.assertEqual(first, second)

            transaction.cursor.commit()

        with Transaction().start(DB_NAME, USER,
                                 context=CONTEXT) as transaction:
            history = History(history_id)
            history.value = 3
            history.save()

            transaction.cursor.commit()

        with Transaction().start(DB_NAME, USER, context=CONTEXT):
            History.restore_history([history_id], first)
            history = History(history_id)
            self.assertEqual(history.value, 2)
Exemplo n.º 47
0
    def test0020_create_product_duplicate(self):
        """
        Tests if items imported from ebay is duplicated as product in tryton
        """
        Product = POOL.get('product.product')

        with Transaction().start(DB_NAME, USER, CONTEXT) as txn:

            self.setup_defaults()

            with txn.set_context({
                    'current_channel': self.ebay_channel.id,
                    'company': self.company,
            }):

                ebay_data = load_json('products', '110162956809')

                # Create product
                product = Product.create_using_ebay_data(ebay_data)
                self.assert_(product)

                # Create again and it should fail
                self.assertRaises(
                    UserError,
                    Product.create_using_ebay_data,
                    ebay_data,
                )
Exemplo n.º 48
0
    def test_collection_get_pagination(self):
        """
        GET with a domain
        """
        # Fetch result from tryton api first to compare with rest api
        with Transaction().start(DB_NAME, 0, readonly=True):
            IrModel = POOL.get('ir.model')
            count = IrModel.search_count([])

        with app.test_client() as c:
            total_count = 0
            for page in xrange(1, 100):
                # Try to Iterate over a 100 pages
                result = c.get('/%s/model/ir.model?page=%d' % (DB_NAME, page),
                               headers={'Authorization': get_auth_header()})
                page_count = len(json.loads(result.data)['items'])
                total_count += page_count
                if not page_count:
                    break

            # ensure that the total count matches
            self.assertEqual(total_count, count)

            # Ensure that the empty page is above the range
            self.assertEqual(page - 1, math.ceil(count / 10))
Exemplo n.º 49
0
    def test_0010_simple_txn(self):
        """
        Test if the translations work in a simple env
        """
        IRTranslation = POOL.get('ir.translation')

        s = _("en_US")
        self.assertEqual(s, u'en_US')

        # install translations
        self.set_translations()
        self.update_translations('fr_FR')

        # without setting a tranlsation looking for it gives en_US
        with Transaction().set_context(language="fr_FR"):
            self.assertEqual(s, u'en_US')

        # write a translation for it
        translation, = IRTranslation.search([('module', '=', 'nereid'),
                                             ('src', '=', 'en_US'),
                                             ('lang', '=', 'fr_FR')])
        translation.value = 'fr_FR'
        translation.save()

        with Transaction().set_context(language="fr_FR"):
            self.assertEqual(s, u'fr_FR')
Exemplo n.º 50
0
    def test_0010_send_mails(self, mock_smtp):
        """
        Tests send_mails functionality.
        """
        EmailQueue = POOL.get('email.queue')

        with Transaction().start(DB_NAME, USER, CONTEXT) as transaction:
            # Put some emails in queue
            f = Faker()
            for item in xrange(10):
                EmailQueue.queue_mail(f.email(), f.email(), f.text())

            transaction.commit()

            self.assertEqual(EmailQueue.search([], count=True), 10)
            self.assertEqual(
                EmailQueue.search([('state', '=', 'outbox')], count=True), 10)

        with Transaction().start(DB_NAME, USER, CONTEXT) as transaction:
            # Run cron method to send mails
            EmailQueue.send_all()

        with Transaction().start(DB_NAME, USER, CONTEXT) as transaction:
            self.assertEqual(
                EmailQueue.search([('state', '=', 'sent')], count=True), 10)
Exemplo n.º 51
0
    def test_0090_tier_prices(self):
        """Checks the function field on product price tiers
        """
        PriceList = POOL.get('product.price_list')
        ProductPriceTier = POOL.get('product.price_tier')
        Product = POOL.get('product.product')
        Category = POOL.get('product.category')
        User = POOL.get('res.user')

        with Transaction().start(DB_NAME, USER, CONTEXT) as txn:
            self.setup_defaults()
            context = User.get_preferences(context_only=True)
            context.update({
                'current_channel': self.channel1.id,
                'company': self.company.id,
            })
            with txn.set_context(context):
                category_data = load_json('categories', '17')
                Category.create_using_magento_data(category_data)

                product_data = load_json('products', '135')
                product = Product.find_or_create_using_magento_data(
                    product_data
                )

                price_list, = PriceList.create([{
                    'name': 'Test Pricelist',
                    'lines': [('create', [{
                        'quantity': 10,
                        'formula': 'unit_price*0.9'
                    }])]
                }])
                self.channel1.price_list = price_list
                self.channel1.save()

                self.assertEqual(len(product.channel_listings), 1)

                listing = product.channel_listings[0]

                tier, = ProductPriceTier.create([{
                    'product_listing': listing.id,
                    'quantity': 10,
                }])

                self.assertEqual(
                    listing.product.list_price * Decimal('0.9'), tier.price
                )
Exemplo n.º 52
0
    def test_0010_import_sale_order(self):
        """
        Tests import of sale order using ebay data with ebay state as new
        """
        Sale = POOL.get('sale.sale')
        Party = POOL.get('party.party')
        Product = POOL.get('product.product')

        with Transaction().start(DB_NAME, USER, CONTEXT):
            self.setup_defaults()

            with Transaction().set_context({
                    'current_channel':
                    self.ebay_channel.id,
                    'company':
                    self.company
            }):

                orders = Sale.search([])
                self.assertEqual(len(orders), 0)

                order_data = load_json('orders',
                                       '283054010')['OrderArray']['Order'][0]

                Party.create_using_ebay_data(
                    load_json('users', 'testuser_ritu123'))

                Product.create_using_ebay_data(
                    load_json('products', '110162956809'))
                Product.create_using_ebay_data(
                    load_json('products', '110162957156'))

                order1 = self.ebay_channel.import_order(order_data)

                self.assertEqual(order1.state, 'confirmed')

                orders = Sale.search([])
                self.assertEqual(len(orders), 1)

                # Item lines + shipping line should be equal to lines on tryton
                self.assertEqual(len(order1.lines), 3)

                order2 = self.ebay_channel.import_order(order_data)
                orders = Sale.search([])
                self.assertEqual(len(orders), 1)

                self.assertEqual(order1, order2)
Exemplo n.º 53
0
    def test_0110_export_catalog(self):
        """
        Check the export of product catalog to magento.
        This method does not check the API calls.
        """
        ProductTemplate = POOL.get('product.template')
        Category = POOL.get('product.category')
        Uom = POOL.get('product.uom')

        with Transaction().start(DB_NAME, USER, CONTEXT) as txn:
            self.setup_defaults()

            with txn.set_context({
                    'magento_instance': self.instance1.id,
                    'magento_website': self.website1.id,
                    'magento_attribute_set': 1,
                    'company': self.company.id,
            }):
                category_data = load_json('categories', '17')
                category = Category.create_using_magento_data(category_data)

                uom, = Uom.search([('name', '=', 'Unit')], limit=1)
                product, = ProductTemplate.create([{
                    'name':
                    'Test product',
                    'list_price':
                    Decimal('100'),
                    'cost_price':
                    Decimal('1'),
                    'account_expense':
                    self.get_account_by_kind('expense'),
                    'account_revenue':
                    self.get_account_by_kind('revenue'),
                    'default_uom':
                    uom.id,
                    'sale_uom':
                    uom.id,
                    'products': [('create', [{
                        'code':
                        'code',
                        'description':
                        'This is a product description',
                    }])]
                }])

                with patch('magento.Product', mock_product_api(), create=True):
                    product.export_to_magento(category)
Exemplo n.º 54
0
    def test_0030_import_sale_order_with_products_with_new(self):
        """
        Tests import of sale order using magento data with magento state as new
        """
        Sale = POOL.get('sale.sale')
        Party = POOL.get('party.party')
        Category = POOL.get('product.category')

        with Transaction().start(DB_NAME, USER, CONTEXT):
            self.setup_defaults()

            with Transaction().set_context({
                    'magento_instance': self.instance1.id,
                    'magento_store_view': self.store_view,
                    'magento_website': self.website1.id,
            }):

                category_tree = load_json('categories', 'category_tree')
                Category.create_tree_using_magento_data(category_tree)

                orders = Sale.search([])
                self.assertEqual(len(orders), 0)

                order_data = load_json('orders', '100000001')

                with patch('magento.Customer',
                           mock_customer_api(),
                           create=True):
                    Party.find_or_create_using_magento_id(
                        order_data['customer_id'])

                with Transaction().set_context(company=self.company):
                    # Create sale order using magento data
                    with patch('magento.Product',
                               mock_product_api(),
                               create=True):
                        order = Sale.find_or_create_using_magento_data(
                            order_data)

                self.assertEqual(order.state, 'confirmed')

                orders = Sale.search([])
                self.assertEqual(len(orders), 1)

                # Item lines + shipping line should be equal to lines on tryton
                self.assertEqual(len(order.lines),
                                 len(order_data['items']) + 1)
    def test_0020_test_paying_invoice_with_new_credit_card(self):
        """
        Create and pay an invoice using payment transaction
        """
        Date = POOL.get('ir.date')

        self.setup_defaults()

        invoice = self.create_and_post_invoice(self.party)

        self.assertTrue(invoice)
        self.assertEqual(invoice.state, 'posted')
        self.assertTrue(invoice.amount_to_pay)

        # Pay invoice using cash transaction
        Wizard = POOL.get(
            'account.invoice.pay_using_transaction', type='wizard'
        )
        with Transaction().set_context(active_id=invoice.id):
            pay_wizard = Wizard(Wizard.create()[0])
            defaults = pay_wizard.default_start()

            pay_wizard.start.invoice = defaults['invoice']
            pay_wizard.start.party = defaults['party']
            pay_wizard.start.company = defaults['company']
            pay_wizard.start.credit_account = defaults['credit_account']
            pay_wizard.start.owner = defaults['owner']
            pay_wizard.start.currency_digits = defaults['currency_digits']
            pay_wizard.start.amount = defaults['amount']
            pay_wizard.start.user = defaults['user']
            pay_wizard.start.gateway = self.dummy_gateway.id
            pay_wizard.start.payment_profile = None
            pay_wizard.start.reference = 'Test paying with cash'
            pay_wizard.start.method = self.dummy_gateway.method
            pay_wizard.start.use_existing_card = False
            pay_wizard.start.number = '4111111111111111'
            pay_wizard.start.expiry_month = '05'
            pay_wizard.start.expiry_year = '%s' % (Date.today().year + 3)
            pay_wizard.start.csc = '435'
            pay_wizard.start.provider = self.dummy_gateway.provider
            pay_wizard.start.transaction_type = defaults['transaction_type']

            with Transaction().set_context(company=self.company.id):
                pay_wizard.transition_pay()

        self.assertEqual(invoice.state, 'paid')
        self.assertFalse(invoice.amount_to_pay)
Exemplo n.º 56
0
    def test_0032_import_sale_order_without_firstname_and_lastname(self):
        """
        Tests import of sale order using magento data without customer firstname
        and lastname
        """
        Sale = POOL.get('sale.sale')
        Party = POOL.get('party.party')
        Category = POOL.get('product.category')

        with Transaction().start(DB_NAME, USER, CONTEXT):
            self.setup_defaults()

            with Transaction().set_context({
                    'current_channel': self.channel1.id,
            }):

                category_tree = load_json('categories', 'category_tree')
                Category.create_tree_using_magento_data(category_tree)

                orders = Sale.search([])
                self.assertEqual(len(orders), 0)

                order_data = load_json('orders', '100000002')

                with patch('magento.Customer',
                           mock_customer_api(),
                           create=True):
                    Party.find_or_create_using_magento_id(
                        order_data['customer_id'])

                with Transaction().set_context(company=self.company):
                    # Create sale order using magento data
                    with patch('magento.Product',
                               mock_product_api(),
                               create=True):
                        order = Sale.find_or_create_using_magento_data(
                            order_data)

                self.assertEqual(order.state, 'confirmed')
                self.assertFalse(order.has_channel_exception)

                orders = Sale.search([])
                self.assertEqual(len(orders), 1)

                # Item lines + shipping line should be equal to lines on tryton
                self.assertEqual(len(order.lines),
                                 len(order_data['items']) + 1)
Exemplo n.º 57
0
    def test_0040_find_or_create_order_using_increment_id(self):
        """
        Tests finding and creating order using increment id
        """
        Sale = POOL.get('sale.sale')
        Party = POOL.get('party.party')
        Category = POOL.get('product.category')

        with Transaction().start(DB_NAME, USER, CONTEXT):
            self.setup_defaults()
            with Transaction().set_context({
                    'current_channel': self.channel1.id,
            }):

                category_tree = load_json('categories', 'category_tree')
                Category.create_tree_using_magento_data(category_tree)

                orders = Sale.search([])
                self.assertEqual(len(orders), 0)

                order_data = load_json('orders', '100000001')

                with patch('magento.Customer',
                           mock_customer_api(),
                           create=True):
                    Party.find_or_create_using_magento_id(
                        order_data['customer_id'])

                with Transaction().set_context(company=self.company):
                    # Create sale order using magento increment_id
                    with patch('magento.Order', mock_order_api(), create=True):
                        with patch('magento.Product',
                                   mock_product_api(),
                                   create=True):
                            order = \
                                Sale.find_or_create_using_magento_increment_id(
                                    order_data['increment_id']
                                )
                self.assertEqual(order.state, 'confirmed')

                orders = Sale.search([])

                self.assertEqual(len(orders), 1)

                # Item lines + shipping line should be equal to lines on tryton
                self.assertEqual(len(order.lines),
                                 len(order_data['items']) + 1)
    def test_0060_test_duplicate_payment_profile(self):
        """
        Test that workflow is not effected if duplicate payment profile
        is there on authorize.net
        """
        self.setup_defaults()
        expiry_year = str(date.today().year + 1)

        customer = authorize.Customer.create()
        authorize.CreditCard.create(
            customer.customer_id, {
                'credit_card': {
                    'card_number': '4111111111111111',
                    'card_code': '523',
                    'expiration_date': '05/%s' % expiry_year,
                },
                'billing':
                self.party2.addresses[0].get_authorize_address('Test User'),
            })

        # Create a payment profile with some random payment id
        payment_profile = self.PaymentProfile(
            party=self.party2,
            address=self.party2.addresses[0].id,
            gateway=self.auth_net_gateway.id,
            last_4_digits='1111',
            expiry_month='05',
            expiry_year=expiry_year,
            provider_reference='67382920',
            authorize_profile_id=customer.customer_id,
        )
        payment_profile.save()

        # Create payment profile with same details as above
        ProfileWizard = POOL.get('party.party.payment_profile.add',
                                 type="wizard")

        profile_wizard = ProfileWizard(ProfileWizard.create()[0])
        profile_wizard.card_info.owner = 'Test User'
        profile_wizard.card_info.number = '4111111111111111'
        profile_wizard.card_info.expiry_month = '05'
        profile_wizard.card_info.expiry_year = expiry_year
        profile_wizard.card_info.csc = '523'
        profile_wizard.card_info.gateway = self.auth_net_gateway
        profile_wizard.card_info.provider = self.auth_net_gateway.provider
        profile_wizard.card_info.address = self.party2.addresses[0]
        profile_wizard.card_info.party = self.party2

        with Transaction().set_context(return_profile=True):
            profile = profile_wizard.transition_add()

        self.assertEqual(profile.party.id, self.party2.id)
        self.assertEqual(profile.gateway, self.auth_net_gateway)
        self.assertEqual(profile.last_4_digits, '1111')
        self.assertEqual(profile.expiry_month, '05')
        self.assertEqual(profile.expiry_year, expiry_year)
        self.assertIsNotNone(profile.authorize_profile_id)
        self.assertEqual(profile.authorize_profile_id,
                         payment_profile.authorize_profile_id)
Exemplo n.º 59
0
    def test_0070_guest_use_delivery_as_billing(self):
        "Guest user uses shipping address for billing"
        self.setup_defaults()
        app = self.get_app()

        Sale = POOL.get('sale.sale')

        country = self.Country(self.available_countries[0])
        subdivision = country.subdivisions[0]

        with app.test_client() as c:
            c.post('/cart/add',
                   data={
                       'product': self.product1.id,
                       'quantity': 5
                   })

            # Sign-in
            rv = c.post('/checkout/sign-in',
                        data={
                            'email': '*****@*****.**',
                            'checkout_mode': 'guest',
                        })

            # Shipping address page gets rendered
            rv = c.post('/checkout/shipping-address',
                        data={
                            'name': 'Sharoon Thomas',
                            'street': 'Biscayne Boulevard',
                            'streetbis': 'Apt. 1906, Biscayne Park',
                            'zip': 'FL33137',
                            'city': 'Miami',
                            'country': country.id,
                            'subdivision': subdivision.id,
                        })
            self.assertEqual(rv.status_code, 302)

            # Post to delivery-address with same flag
            rv = c.post('/checkout/billing-address',
                        data={'use_shipment_address': 'True'})
            self.assertEqual(rv.status_code, 302)
            self.assertTrue(rv.location.endswith('/checkout/payment'))

            # Assert that just one address was created
            party, = self.Party.search([
                ('contact_mechanisms.value', '=', '*****@*****.**'),
                ('contact_mechanisms.type', '=', 'email')
            ])
            self.assertTrue(party)
            self.assertEqual(len(party.addresses), 1)

            address, = party.addresses
            self.assertEqual(address.street, 'Biscayne Boulevard')

            sales = Sale.search([
                ('shipment_address', '=', address.id),
                ('invoice_address', '=', address.id),
            ])
            self.assertEqual(len(sales), 1)
Exemplo n.º 60
0
    def _get_account_by_kind(self, kind, company=None, silent=True):
        """Returns an account with given spec
        :param kind: receivable/payable/expense/revenue
        :param silent: dont raise error if account is not found
        """
        Account = POOL.get('account.account')
        Company = POOL.get('company.company')

        if company is None:
            company, = Company.search([], limit=1)

        accounts = Account.search([('kind', '=', kind),
                                   ('company', '=', company)],
                                  limit=1)
        if not accounts and not silent:
            raise Exception("Account not found")
        return accounts[0] if accounts else False