コード例 #1
1
    def test_long_cache_keys_shortened(self):
        cache_settings = {
            'default': {
                'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
                'LOCATION': os.path.join(TOP_DIR, 'test.cache'),
            }
        }
        long_key_string = "X" * 251

        with override_settings(CACHES=cache_settings):
            with warnings.catch_warnings(record=True) as w:
                warnings.simplefilter("always")
                # memcached limits key length to 250
                cache.set(long_key_string, "hello cached world")

                self.assertEqual(len(w), 1)
                self.assertIsInstance(w[0].message, CacheKeyWarning)

        # Activate optional cache key length checker
        cache_settings['default']['KEY_FUNCTION'] = 'mainsite.utils.filter_cache_key'

        with override_settings(CACHES=cache_settings):
            with warnings.catch_warnings(record=True) as w:
                warnings.simplefilter("always")
                # memcached limits key length to 250
                cache.set(long_key_string, "hello cached world")

                self.assertEqual(len(w), 0)

                retrieved = cache.get(long_key_string)

                self.assertEqual(retrieved, "hello cached world")
コード例 #2
0
ファイル: tests.py プロジェクト: praekelt/django-recaptcha
 def test_setting_instance_check(self):
     with override_settings(RECAPTCHA_PROXY="not a dict"):
         with self.assertRaises(ImproperlyConfigured) as error:
             reload(captcha)
         self.assertEqual(error.exception.args, (
             "Setting RECAPTCHA_PROXY is not of type", dict)
         )
     with override_settings(RECAPTCHA_VERIFY_REQUEST_TIMEOUT="not an int"):
         with self.assertRaises(ImproperlyConfigured) as error:
             reload(captcha)
         self.assertEqual(error.exception.args, (
             "Setting RECAPTCHA_VERIFY_REQUEST_TIMEOUT is not of type", int)
         )
     with override_settings(RECAPTCHA_DOMAIN=1):
         with self.assertRaises(ImproperlyConfigured) as error:
             reload(captcha)
         self.assertEqual(error.exception.args, (
             "Setting RECAPTCHA_DOMAIN is not of type", str)
         )
     with override_settings(RECAPTCHA_PUBLIC_KEY=1):
         with self.assertRaises(ImproperlyConfigured) as error:
             reload(captcha)
         self.assertEqual(error.exception.args, (
             "Setting RECAPTCHA_PUBLIC_KEY is not of type", str)
         )
     with override_settings(RECAPTCHA_PRIVATE_KEY=1):
         with self.assertRaises(ImproperlyConfigured) as error:
             reload(captcha)
         self.assertEqual(error.exception.args, (
             "Setting RECAPTCHA_PRIVATE_KEY is not of type", str)
         )
コード例 #3
0
ファイル: tests.py プロジェクト: daiqingyang/django
    def test_is_extendable(self):
        """
        Tests that the XFrameOptionsMiddleware method that determines the
        X-Frame-Options header value can be overridden based on something in
        the request or response.
        """

        class OtherXFrameOptionsMiddleware(XFrameOptionsMiddleware):
            # This is just an example for testing purposes...
            def get_xframe_options_value(self, request, response):
                if getattr(request, "sameorigin", False):
                    return "SAMEORIGIN"
                if getattr(response, "sameorigin", False):
                    return "SAMEORIGIN"
                return "DENY"

        with override_settings(X_FRAME_OPTIONS="DENY"):
            response = HttpResponse()
            response.sameorigin = True
            r = OtherXFrameOptionsMiddleware().process_response(HttpRequest(), response)
            self.assertEqual(r["X-Frame-Options"], "SAMEORIGIN")

            request = HttpRequest()
            request.sameorigin = True
            r = OtherXFrameOptionsMiddleware().process_response(request, HttpResponse())
            self.assertEqual(r["X-Frame-Options"], "SAMEORIGIN")

        with override_settings(X_FRAME_OPTIONS="SAMEORIGIN"):
            r = OtherXFrameOptionsMiddleware().process_response(HttpRequest(), HttpResponse())
            self.assertEqual(r["X-Frame-Options"], "DENY")
コード例 #4
0
 def test_resolver_translation(self):
     with override_settings(USE_SUBDOMAIN=False):
         url = resolve_path(project=self.translation, filename='index.html')
         self.assertEqual(url, '/docs/pip/ja/latest/')
     with override_settings(USE_SUBDOMAIN=True):
         url = resolve_path(project=self.translation, filename='index.html')
         self.assertEqual(url, '/ja/latest/')
コード例 #5
0
 def test_resolver_subdomain(self):
     with override_settings(USE_SUBDOMAIN=False):
         url = resolve_path(project=self.pip, filename='index.html')
         self.assertEqual(url, '/docs/pip/en/latest/')
     with override_settings(USE_SUBDOMAIN=True):
         url = resolve_path(project=self.pip, filename='index.html')
         self.assertEqual(url, '/en/latest/')
コード例 #6
0
 def test_resolver_private_project(self):
     with override_settings(USE_SUBDOMAIN=False):
         url = resolve(project=self.pip, private=True)
         self.assertEqual(url, 'http://readthedocs.org/docs/pip/en/latest/')
     with override_settings(USE_SUBDOMAIN=True):
         url = resolve(project=self.pip, private=True)
         self.assertEqual(url, 'http://pip.readthedocs.org/en/latest/')
コード例 #7
0
 def test_resolver_translation(self):
     with override_settings(USE_SUBDOMAIN=False):
         url = resolve(project=self.translation)
         self.assertEqual(url, 'http://readthedocs.org/docs/pip/ja/latest/')
     with override_settings(USE_SUBDOMAIN=True):
         url = resolve(project=self.translation)
         self.assertEqual(url, 'http://pip.readthedocs.org/ja/latest/')
コード例 #8
0
ファイル: test_basket_customer.py プロジェクト: ruqaiya/shuup
def test_create_new_basket(admin_user):
    with override_settings(**REQUIRED_SETTINGS):
        shop = factories.get_default_shop()
        shop2 = create_shop("foobar")
        client = _get_client(admin_user)
        response = client.post("/api/shuup/basket/new/", {
            "shop": shop2.pk
        })
        assert response.status_code == status.HTTP_201_CREATED
        basket_data = json.loads(response.content.decode("utf-8"))
        basket = Basket.objects.first()
        assert basket.key == basket_data['uuid'].split("-")[1]
        assert basket.shop == shop2
        admin_contact = get_person_contact(admin_user)
        assert basket.customer == admin_contact
        assert basket.orderer == admin_contact
        assert basket.creator == admin_user

        # invalid shop
        response = client.post("/api/shuup/basket/new/", data={"shop": 1000})
        assert response.status_code == status.HTTP_400_BAD_REQUEST

        # no shop in multishop mode
        response = client.post("/api/shuup/basket/new/")
        assert response.status_code == status.HTTP_400_BAD_REQUEST

        # no shop in single shop mode
        with override_settings(SHUUP_ENABLE_MULTIPLE_SHOPS=False):
            response = client.post("/api/shuup/basket/new/")
            assert response.status_code == status.HTTP_201_CREATED
            basket_data = json.loads(response.content.decode("utf-8"))
            basket = Basket.objects.all()[1]
            assert basket.key == basket_data['uuid'].split("-")[1]
            assert basket.shop == shop
            assert basket.customer == admin_contact
            assert basket.orderer == admin_contact
            assert basket.creator == admin_user

            person = factories.create_random_person()

            response = client.post("/api/shuup/basket/new/", data={"customer": person.pk})
            assert response.status_code == status.HTTP_201_CREATED
            basket_data = json.loads(response.content.decode("utf-8"))
            basket = Basket.objects.all()[2]
            assert basket.key == basket_data['uuid'].split("-")[1]
            assert basket.shop == shop
            assert basket.creator == admin_user
            assert basket.customer.pk == person.pk
            assert basket.orderer.pk == person.pk
            assert basket.creator.pk == admin_user.pk

            # Try to fetch the basket as the customer
            user = factories.UserFactory()
            person.user = user
            person.save()
            response = client.get("/api/shuup/basket/{}/".format(basket_data['uuid']))
            assert response.status_code == 200
            customer_basket_data = json.loads(response.content.decode("utf-8"))
            assert basket.key == customer_basket_data['key']  # Still same basket as before
            assert customer_basket_data['customer']['id'] == person.pk  # Still same customer as before
コード例 #9
0
ファイル: test_addresses.py プロジェクト: NamiStudio/shuup
def test_home_country_in_address():
    with override("fi"):
        finnish_address = MutableAddress(country="FI")
        with override_settings(SHUUP_ADDRESS_HOME_COUNTRY="US"):
            assert "Suomi" in str(finnish_address), "When home is not Finland, Finland appears in address string"
        with override_settings(SHUUP_ADDRESS_HOME_COUNTRY="FI"):
            assert "Suomi" not in str(finnish_address), "When home is Finland, Finland does not appear in address string"
コード例 #10
0
ファイル: tests.py プロジェクト: barbuza/django-robust
    def test_limit(self):
        with transaction.atomic():
            runtime = timezone.now()
            Task.objects.create(name=TEST_TASK_PATH, tags=['foo', 'bar'])
            RateLimitRun.objects.bulk_create([
                RateLimitRun(tag='foo', created_at=runtime),
                RateLimitRun(tag='bar', created_at=runtime),
                RateLimitRun(tag='bar', created_at=runtime)
            ])
            t1 = Task.objects.create(name=TEST_TASK_PATH, tags=['bar', 'spam'])
            t2 = Task.objects.create(name=TEST_TASK_PATH, tags=['foo'])

        with transaction.atomic():
            with override_settings(ROBUST_RATE_LIMIT={
                'foo': (1, timedelta(minutes=1)),
                'bar': (10, timedelta(minutes=1))
            }):
                self.assertSequenceEqual(Task.objects.next(limit=10), [t1])

        with transaction.atomic():
            with override_settings(ROBUST_RATE_LIMIT={
                'foo': (3, timedelta(minutes=1)),
                'bar': (2, timedelta(minutes=1))
            }):
                self.assertSequenceEqual(Task.objects.next(limit=10), [t2])
コード例 #11
0
def test_bower_get_rc_file():
	"""Tests that the .bowerrc file is discoverable and usable as a JSON object"""
	with override_settings(BOWER_RC_FILE='/path/to/rc'):
		assert_equal(bower.get_bower_rc_path(), '/path/to/rc')

	with override_settings():
		assert_equal(bower.get_bower_rc_path(), os.getcwd() + '/.bowerrc')
コード例 #12
0
def test_get_resource_name():
    view = APIView()
    context = {'view': view}
    with override_settings(JSON_API_FORMAT_TYPES=None):
        assert 'APIViews' == utils.get_resource_name(context), 'not formatted'

    context = {'view': view}
    with override_settings(JSON_API_FORMAT_TYPES='dasherize'):
        assert 'api-views' == utils.get_resource_name(context), 'derived from view'

    view.model = get_user_model()
    assert 'users' == utils.get_resource_name(context), 'derived from view model'

    view.resource_name = 'custom'
    assert 'custom' == utils.get_resource_name(context), 'manually set on view'

    view.response = Response(status=403)
    assert 'errors' == utils.get_resource_name(context), 'handles 4xx error'

    view.response = Response(status=500)
    assert 'errors' == utils.get_resource_name(context), 'handles 500 error'

    view = GenericAPIView()
    view.serializer_class = ResourceSerializer
    context = {'view': view}
    assert 'users' == utils.get_resource_name(context), 'derived from serializer'

    view.serializer_class.Meta.resource_name = 'rcustom'
    assert 'rcustom' == utils.get_resource_name(context), 'set on serializer'

    view = GenericAPIView()
    view.serializer_class = NonModelResourceSerializer
    context = {'view': view}
    assert 'users' == utils.get_resource_name(context), 'derived from non-model serializer'
コード例 #13
0
def test_coupon_creation_for_supplier(rf, admin_user):
    """
    To make things little bit more simple let's use only english as
    a language.
    """
    shop = get_default_shop()
    supplier = Supplier.objects.create(identifier=admin_user.username)
    
    another_superuser = create_random_user(is_superuser=True, is_staff=True)
    supplier2 = Supplier.objects.create(identifier=another_superuser.username)

    supplier_provider = "shuup.testing.supplier_provider.UsernameSupplierProvider"
    with override_settings(LANGUAGES=[("en", "en")]):
        with override_settings(SHUUP_ADMIN_SUPPLIER_PROVIDER_SPEC=supplier_provider):
            view = CouponEditView.as_view()
            data = {
                "code": "OK",
                "active": True,
                "shop": shop.pk
            }
            coupons_before = Coupon.objects.count()
            request = apply_request_middleware(rf.post("/", data=data), user=admin_user)
            assert get_supplier(request) == supplier
            response = view(request, pk=None)
            assert response.status_code in [200, 302]
            assert Coupon.objects.count() == (coupons_before + 1)

            new_coupon = Coupon.objects.filter(supplier=supplier).first()
            assert new_coupon

            # Another superuser shouldn't see this campaign
            request = apply_request_middleware(rf.post("/", data=data), user=another_superuser)
            assert get_supplier(request) == supplier2
            with pytest.raises(Http404):
                response = view(request, pk=new_coupon.pk)
コード例 #14
0
    def test_resolver_public_domain_overrides(self):
        with override_settings(USE_SUBDOMAIN=False):
            url = resolve(project=self.pip, private=True)
            self.assertEqual(url, 'http://readthedocs.org/docs/pip/en/latest/')
            url = resolve(project=self.pip, private=False)
            self.assertEqual(url, 'http://readthedocs.org/docs/pip/en/latest/')
        with override_settings(USE_SUBDOMAIN=True):
            url = resolve(project=self.pip, private=True)
            self.assertEqual(
                url, 'http://pip.public.readthedocs.org/en/latest/')
            url = resolve(project=self.pip, private=False)
            self.assertEqual(
                url, 'http://pip.public.readthedocs.org/en/latest/')

        # Domain overrides PUBLIC_DOMAIN
        self.domain = fixture.get(
            Domain,
            domain='docs.foobar.com',
            project=self.pip,
            canonical=True,
        )
        with override_settings(USE_SUBDOMAIN=True):
            url = resolve(project=self.pip, private=True)
            self.assertEqual(url, 'http://docs.foobar.com/en/latest/')
            url = resolve(project=self.pip, private=False)
            self.assertEqual(url, 'http://docs.foobar.com/en/latest/')
        with override_settings(USE_SUBDOMAIN=False):
            url = resolve(project=self.pip, private=True)
            self.assertEqual(url, 'http://docs.foobar.com/en/latest/')
            url = resolve(project=self.pip, private=False)
            self.assertEqual(url, 'http://docs.foobar.com/en/latest/')
コード例 #15
0
    def test_load_balanced_read_apps(self, mock):
        load_balanced_apps = {
            'users': [
                ('users_db1', 5),
            ]
        }

        with override_settings(
            LOAD_BALANCED_APPS=load_balanced_apps,
            DATABASES = {
                'default': _get_db_config('default'),
                'users_db1': _get_db_config('users_db1')}):
            manager = ConnectionManager()
            self.assertEqual(
                manager.get_load_balanced_read_db_alais('users', default="default_option"),
                'users_db1'
            )

        with override_settings(LOAD_BALANCED_APPS=load_balanced_apps):
            # load_balanced_db should be part of settings.DATABASES
            with self.assertRaises(AssertionError):
                ConnectionManager().get_load_balanced_read_db_alais('users')


        # If `LOAD_BALANCED_APPS` is not set for an app, it should point to default kwarg
        manager = ConnectionManager()
        self.assertEqual(
            manager.get_load_balanced_read_db_alais('users', default='default_option'),
            'default_option'
        )
コード例 #16
0
    def test_read_load_balancing(self, *args):
        reporting_dbs = {
            'ucr': {
                'WRITE': 'ucr',
                'READ': [('ucr', 8), ('other', 1), ('default', 1)]
            },
        }
        with override_settings(REPORTING_DATABASES=reporting_dbs):
            manager = ConnectionManager()
            self.assertEqual(manager.db_connection_map, {
                'default': 'postgresql+psycopg2://:@localhost:5432/default',
                'ucr': 'postgresql+psycopg2://:@localhost:5432/ucr',
                'other': 'postgresql+psycopg2://:@localhost:5432/other'
            })


            # test that load balancing works with a 10% margin for randomness
            total_requests = 10000
            randomness_margin = total_requests * 0.1
            total_weighting = sum(db[1] for db in reporting_dbs['ucr']['READ'])
            expected = {
                alias: weight * total_requests // total_weighting
                for alias, weight in reporting_dbs['ucr']['READ']
            }
            balanced = Counter(manager.get_load_balanced_read_db_alais('ucr') for i in range(total_requests))
            for db, requests in balanced.items():
                self.assertAlmostEqual(requests, expected[db], delta=randomness_margin)

        with override_settings(REPORTING_DATABASES={'default': 'default'}):
            manager = ConnectionManager()
            self.assertEqual(
                ['default', 'default', 'default'],
                [manager.get_load_balanced_read_db_alais('default') for i in range(3)]
            )
コード例 #17
0
 def test_domain_resolver_translation(self):
     with override_settings(USE_SUBDOMAIN=False):
         url = resolve_domain(project=self.translation)
         self.assertEqual(url, 'readthedocs.org')
     with override_settings(USE_SUBDOMAIN=True):
         url = resolve_domain(project=self.translation)
         self.assertEqual(url, 'pip.readthedocs.org')
コード例 #18
0
ファイル: tests.py プロジェクト: rklabs/django
    def test_override_settings_nested(self):
        """
        override_settings uses the actual _wrapped attribute at
        runtime, not when it was instantiated.
        """

        with self.assertRaises(AttributeError):
            getattr(settings, 'TEST')
        with self.assertRaises(AttributeError):
            getattr(settings, 'TEST2')

        inner = override_settings(TEST2='override')
        with override_settings(TEST='override'):
            self.assertEqual('override', settings.TEST)
            with inner:
                self.assertEqual('override', settings.TEST)
                self.assertEqual('override', settings.TEST2)
            # inner's __exit__ should have restored the settings of the outer
            # context manager, not those when the class was instantiated
            self.assertEqual('override', settings.TEST)
            with self.assertRaises(AttributeError):
                getattr(settings, 'TEST2')

        with self.assertRaises(AttributeError):
            getattr(settings, 'TEST')
        with self.assertRaises(AttributeError):
            getattr(settings, 'TEST2')
コード例 #19
0
 def test_resolver_subproject_single_version(self):
     self.subproject.single_version = True
     with override_settings(USE_SUBDOMAIN=False):
         url = resolve_path(project=self.subproject, filename='index.html')
         self.assertEqual(url, '/docs/pip/projects/sub/')
     with override_settings(USE_SUBDOMAIN=True):
         url = resolve_path(project=self.subproject, filename='index.html')
         self.assertEqual(url, '/projects/sub/')
コード例 #20
0
 def test_resolver_single_version(self):
     self.pip.single_version = True
     with override_settings(USE_SUBDOMAIN=False):
         url = resolve(project=self.pip)
         self.assertEqual(url, 'http://readthedocs.org/docs/pip/')
     with override_settings(USE_SUBDOMAIN=True):
         url = resolve(project=self.pip)
         self.assertEqual(url, 'http://pip.readthedocs.org/')
コード例 #21
0
def test_product_categories(settings):
    with override_settings(SHUUP_AUTO_SHOP_PRODUCT_CATEGORIES=True):
        shop_product = get_default_shop_product()
        shop_product.categories.clear()
        shop_product.primary_category = None
        shop_product.save()

        assert not shop_product.primary_category
        assert not shop_product.categories.count()

        category_one = CategoryFactory()
        category_two = CategoryFactory()

        shop_product.categories = Category.objects.all()

        assert shop_product.primary_category  # this was automatically populated
        assert shop_product.primary_category.pk == category_one.pk  # it's the first one also

        shop_product.categories.clear()

        shop_product.primary_category = category_one
        shop_product.save()

        assert shop_product.primary_category == category_one
        assert category_one in shop_product.categories.all()

        # test removing
        shop_product.categories.remove(category_one)
        shop_product.refresh_from_db()
        assert not shop_product.categories.exists()

        shop_product.categories.add(category_one)
        category_one.soft_delete()
        assert not shop_product.categories.exists()

    with override_settings(SHUUP_AUTO_SHOP_PRODUCT_CATEGORIES=False):
        shop_product.categories.clear()
        shop_product.primary_category = None
        shop_product.save()

        assert not shop_product.primary_category
        assert not shop_product.categories.count()

        category_one = CategoryFactory()
        category_two = CategoryFactory()

        shop_product.categories = Category.objects.all()

        assert not shop_product.primary_category  # this was NOT automatically populated

        shop_product.categories.clear()

        shop_product.primary_category = category_one
        shop_product.save()

        assert shop_product.primary_category == category_one
        assert category_one not in shop_product.categories.all()
コード例 #22
0
ファイル: test_utils.py プロジェクト: ArabellaTech/ydcommon
    def test_settings(self):
        # test old Django configuration
        template_dirs = ['a', 'b']
        with override_settings(TEMPLATES=[{'BACKEND': '1'}], TEMPLATE_DIRS=template_dirs):
            self.assertListEqual(get_template_dirs(), template_dirs)

        # test Django > 1.8
        with override_settings(TEMPLATES=[{'BACKEND': '1', 'DIRS': template_dirs}]):
            self.assertListEqual(get_template_dirs(), template_dirs)
コード例 #23
0
 def test_resolver_force_language(self):
     with override_settings(USE_SUBDOMAIN=False):
         url = resolve_path(
             project=self.pip, filename='index.html', language='cz')
         self.assertEqual(url, '/docs/pip/cz/latest/')
     with override_settings(USE_SUBDOMAIN=True):
         url = resolve_path(
             project=self.pip, filename='index.html', language='cz')
         self.assertEqual(url, '/cz/latest/')
コード例 #24
0
 def test_resolver_force_version(self):
     with override_settings(USE_SUBDOMAIN=False):
         url = resolve_path(
             project=self.pip, filename='index.html', version_slug='foo')
         self.assertEqual(url, '/docs/pip/en/foo/')
     with override_settings(USE_SUBDOMAIN=True):
         url = resolve_path(
             project=self.pip, filename='index.html', version_slug='foo')
         self.assertEqual(url, '/en/foo/')
コード例 #25
0
 def test_resolver_subproject(self):
     with override_settings(USE_SUBDOMAIN=False):
         url = resolve(project=self.subproject)
         self.assertEqual(
             url, 'http://readthedocs.org/docs/pip/projects/sub/ja/latest/')
     with override_settings(USE_SUBDOMAIN=True):
         url = resolve(project=self.subproject)
         self.assertEqual(
             url, 'http://pip.readthedocs.org/projects/sub/ja/latest/')
コード例 #26
0
ファイル: test_models.py プロジェクト: openhealthcare/elcid
    def test_not_called_on_update(self, patient_query, subscribe):
        with override_settings(GLOSS_ENABLED=False):
            episode = self.patient.create_episode()

        with override_settings(GLOSS_ENABLED=True):
            episode.save()

        self.assertFalse(patient_query.called)
        self.assertFalse(subscribe.called)
コード例 #27
0
 def test_resolver_force_single_version(self):
     self.pip.single_version = False
     with override_settings(USE_SUBDOMAIN=False):
         url = resolve_path(
             project=self.pip, filename='index.html', single_version=True)
         self.assertEqual(url, '/docs/pip/')
     with override_settings(USE_SUBDOMAIN=True):
         url = resolve_path(
             project=self.pip, filename='index.html', single_version=True)
         self.assertEqual(url, '/')
コード例 #28
0
def test_bower_get_executable():
	"""Tests that the get_bower_cmd() finds the path to the bower executable"""
	# Verify django settings override option
	with override_settings(BOWER_CMD='/override/path'):
		assert_equal(bower.get_bower_executable_path(), '/override/path')

	with override_settings():
		with mock.patch('django_collectstatic_bower.bower.which') as which:
			which.return_value = '/discovered/path'
			assert_equal(bower.get_bower_executable_path(), '/discovered/path')
コード例 #29
0
ファイル: test_multidb.py プロジェクト: ArcTanSusan/django
 def test_create_model4(self):
     """
     Test multiple routers.
     """
     with override_settings(DATABASE_ROUTERS=[AgnosticRouter(), AgnosticRouter()]):
         self._test_create_model("test_mltdb_crmo4", should_run=True)
     with override_settings(DATABASE_ROUTERS=[MigrateNothingRouter(), MigrateEverythingRouter()]):
         self._test_create_model("test_mltdb_crmo4", should_run=False)
     with override_settings(DATABASE_ROUTERS=[MigrateEverythingRouter(), MigrateNothingRouter()]):
         self._test_create_model("test_mltdb_crmo4", should_run=True)
コード例 #30
0
ファイル: test_management.py プロジェクト: GeyseR/django
 def test_404_response(self):
     command = runserver.Command()
     handler = command.get_handler(use_static_handler=True, insecure_serving=True)
     missing_static_file = os.path.join(settings.STATIC_URL, 'unknown.css')
     req = RequestFactory().get(missing_static_file)
     with override_settings(DEBUG=False):
         response = handler.get_response(req)
         self.assertEqual(response.status_code, 404)
     with override_settings(DEBUG=True):
         response = handler.get_response(req)
         self.assertEqual(response.status_code, 404)
コード例 #31
0
ファイル: test_checkout.py プロジェクト: wanuop/shuup
def test_browser_checkout_vertical(browser, live_server, settings): 
    with override_settings(SHUUP_CHECKOUT_VIEW_SPEC=("shuup.front.views.checkout:SinglePageCheckoutView")):
        # initialize
        product_name = "Test Product"
        get_default_shop()
        pm = get_default_payment_method()
        sm = get_default_shipping_method()
        product = create_orderable_product(product_name, "test-123", price=100)
        OrderStatus.objects.create(
            identifier="initial",
            role=OrderStatusRole.INITIAL,
            name="initial",
            default=True
        )

        # initialize test and go to front page
        browser = initialize_front_browser_test(browser, live_server)
        # check that front page actually loaded
        wait_until_condition(browser, lambda x: x.is_text_present("Welcome to Default!"))
        wait_until_condition(browser, lambda x: x.is_text_present("Newest Products"))
        wait_until_condition(browser, lambda x: x.is_text_present(product_name))

        click_element(browser, "#product-%s" % product.pk)  # open product from product list
        click_element(browser, "#add-to-cart-button-%s" % product.pk)  # add product to basket

        wait_until_appeared(browser, ".cover-wrap")
        wait_until_disappeared(browser, ".cover-wrap")

        click_element(browser, "#navigation-basket-partial")  # open upper basket navigation menu
        click_element(browser, "a[href='/basket/']")  # click the link to basket in dropdown
        wait_until_condition(browser, lambda x: x.is_text_present("Shopping cart"))  # we are in basket page
        wait_until_condition(browser, lambda x: x.is_text_present(product_name))  # product is in basket

        click_element(browser, "a[href='/checkout/']") # click link that leads to checkout
        wait_until_appeared(browser, "h4.panel-title")
        customer_name = "Test Tester"
        customer_street = "Test Street"
        customer_city = "Test City"
        customer_region = "CA"
        customer_country = "US"

        # Fill all necessary information
        browser.fill("billing-name", customer_name)
        browser.fill("billing-street", customer_street)
        browser.fill("billing-city", customer_city)
        browser.select("billing-country", customer_country)
        wait_until_appeared(browser, "select[name='billing-region_code']")
        browser.select("billing-region_code", customer_region)

        click_element(browser, "#addresses button[type='submit']")

        wait_until_condition(browser, lambda x: x.is_text_present("This field is required."))

        # Fill the errors
        browser.fill("shipping-name", customer_name)
        browser.fill("shipping-street", customer_street)
        browser.fill("shipping-city", customer_city)
        browser.select("shipping-country", customer_country)

        click_element(browser, "#addresses button[type='submit']")
        wait_until_condition(browser, lambda x: x.is_text_present("Shipping & Payment"))

        wait_until_condition(browser, lambda x: x.is_text_present(sm.name))  # shipping method name is present
        wait_until_condition(browser, lambda x: x.is_text_present(pm.name))  # payment method name is present

        click_element(browser, ".btn.btn-primary.btn-lg.pull-right")  # click "continue" on methods page

        wait_until_condition(browser, lambda x: x.is_text_present("Confirmation"))  # we are indeed in confirmation page

        # See that all expected texts are present
        wait_until_condition(browser, lambda x: x.is_text_present(product_name))
        wait_until_condition(browser, lambda x: x.is_text_present(sm.name))
        wait_until_condition(browser, lambda x: x.is_text_present(pm.name))
        wait_until_condition(browser, lambda x: x.is_text_present("Delivery"))
        wait_until_condition(browser, lambda x: x.is_text_present("Billing"))

        # check that user information is available
        wait_until_condition(browser, lambda x: x.is_text_present(customer_name))
        wait_until_condition(browser, lambda x: x.is_text_present(customer_street))
        wait_until_condition(browser, lambda x: x.is_text_present(customer_city))
        wait_until_condition(browser, lambda x: x.is_text_present("United States"))

        browser.execute_script('document.getElementById("id_accept_terms").checked=true')  # click accept terms
        click_element(browser, ".btn.btn-primary.btn-lg")  # click "place order"

        wait_until_condition(browser, lambda x: x.is_text_present("Thank you for your order!"))  # order succeeded
コード例 #32
0
 def test_fuzzy_compiling(self):
     with override_settings(LOCALE_PATHS=[os.path.join(self.test_dir, 'locale')]):
         call_command('compilemessages', locale=[self.LOCALE], fuzzy=True, stdout=StringIO())
         with translation.override(self.LOCALE):
             self.assertEqual(ugettext('Lenin'), force_text('Ленин'))
             self.assertEqual(ugettext('Vodka'), force_text('Водка'))
コード例 #33
0
ファイル: tests.py プロジェクト: zc-andy/DbMgrSystem
    def test_naturaltime(self):
        class naive(datetime.tzinfo):
            def utcoffset(self, dt):
                return None

        test_list = [
            'test',
            now,
            now - datetime.timedelta(microseconds=1),
            now - datetime.timedelta(seconds=1),
            now - datetime.timedelta(seconds=30),
            now - datetime.timedelta(minutes=1, seconds=30),
            now - datetime.timedelta(minutes=2),
            now - datetime.timedelta(hours=1, minutes=30, seconds=30),
            now - datetime.timedelta(hours=23, minutes=50, seconds=50),
            now - datetime.timedelta(days=1),
            now - datetime.timedelta(days=500),
            now + datetime.timedelta(seconds=1),
            now + datetime.timedelta(seconds=30),
            now + datetime.timedelta(minutes=1, seconds=30),
            now + datetime.timedelta(minutes=2),
            now + datetime.timedelta(hours=1, minutes=30, seconds=30),
            now + datetime.timedelta(hours=23, minutes=50, seconds=50),
            now + datetime.timedelta(days=1),
            now + datetime.timedelta(days=2, hours=6),
            now + datetime.timedelta(days=500),
            now.replace(tzinfo=naive()),
            now.replace(tzinfo=utc),
        ]
        result_list = [
            'test',
            'now',
            'now',
            'a second ago',
            '30\xa0seconds ago',
            'a minute ago',
            '2\xa0minutes ago',
            'an hour ago',
            '23\xa0hours ago',
            '1\xa0day ago',
            '1\xa0year, 4\xa0months ago',
            'a second from now',
            '30\xa0seconds from now',
            'a minute from now',
            '2\xa0minutes from now',
            'an hour from now',
            '23\xa0hours from now',
            '1\xa0day from now',
            '2\xa0days, 6\xa0hours from now',
            '1\xa0year, 4\xa0months from now',
            'now',
            'now',
        ]
        # Because of the DST change, 2 days and 6 hours after the chosen
        # date in naive arithmetic is only 2 days and 5 hours after in
        # aware arithmetic.
        result_list_with_tz_support = result_list[:]
        assert result_list_with_tz_support[
            -4] == '2\xa0days, 6\xa0hours from now'
        result_list_with_tz_support[-4] == '2\xa0days, 5\xa0hours from now'

        orig_humanize_datetime, humanize.datetime = humanize.datetime, MockDateTime
        try:
            with translation.override('en'):
                self.humanize_tester(test_list, result_list, 'naturaltime')
                with override_settings(USE_TZ=True):
                    self.humanize_tester(test_list,
                                         result_list_with_tz_support,
                                         'naturaltime')
        finally:
            humanize.datetime = orig_humanize_datetime
コード例 #34
0
ファイル: test_exam.py プロジェクト: xhijack/relate
    def test_ok_views(self):
        # we only test ta participation
        from course.auth import make_sign_in_key

        # make sign in key for a user
        u = factories.UserFactory(first_name="foo",
                                  last_name="bar",
                                  status=constants.user_status.unconfirmed)
        sign_in_key = make_sign_in_key(u)
        u.sign_in_key = sign_in_key
        u.save()

        self.c.force_login(self.ta_participation.user)

        my_session = factories.FlowSessionFactory(
            participation=self.ta_participation, flow_id=self.flow_id)

        with override_settings(RELATE_SIGN_IN_BY_USERNAME_ENABLED=True):
            for url, args, kwargs, code_or_redirect in [
                ("relate-sign_in_choice", [], {}, 200),
                ("relate-sign_in_by_email", [], {}, 200),
                ("relate-sign_in_stage2_with_token", [u.pk,
                                                      sign_in_key], {}, "/"),
                ("relate-sign_in_by_user_pw", [], {}, 200),
                ("relate-impersonate", [], {}, 200),

                    # because not we are testing get, while stop_impersonating view
                    # doesn't allow get, if it return 403 instead of 302
                    # we think it passed test.
                ("relate-stop_impersonating", [], {}, 403),
                ("relate-check_in_for_exam", [], {}, 200),
                ("relate-list_available_exams", [], {}, 200),
                ("relate-view_start_flow", [], {
                    "course_identifier": self.course.identifier,
                    "flow_id": self.flow_id
                }, 200),
                ("relate-view_resume_flow", [], {
                    "course_identifier": self.course.identifier,
                    "flow_session_id": my_session.pk
                },
                 self.get_page_url_by_ordinal(0,
                                              flow_session_id=my_session.pk)),
                ("relate-user_profile", [], {}, 200),
                ("relate-logout", [], {}, "/"),
                ("relate-set_pretend_facilities", [], {}, 200),
            ]:
                with self.subTest(url=url):
                    if "sign_in" in url:
                        switch_to = None
                    else:
                        switch_to = self.ta_participation.user
                    with self.temporarily_switch_to_user(switch_to):
                        resp = self.c.get(
                            reverse(url, args=args, kwargs=kwargs))
                        try:
                            code = int(code_or_redirect)
                            self.assertEqual(resp.status_code, code)
                        except ValueError:
                            self.assertRedirects(resp,
                                                 code_or_redirect,
                                                 fetch_redirect_response=False)
コード例 #35
0
def test_html_export_full(event, other_event, slot, canceled_talk):
    from django.core.management import call_command
    from django.conf import settings
    import os.path

    event.primary_color = '#111111'
    event.save()
    other_event.primary_color = '#222222'
    other_event.save()

    with override_settings(COMPRESS_ENABLED=True, COMPRESS_OFFLINE=True):
        call_command('rebuild')
        regenerate_css(event.pk)
        regenerate_css(other_event.pk)
        event = Event.objects.get(slug=event.slug)
        assert event.settings.agenda_css_file
        call_command('export_schedule_html', event.slug, '--zip')

    paths = [
        'static/common/img/logo.svg',
        f'media/test/{event.settings.agenda_css_file.split("/")[-1]}',
        'test/schedule/index.html',
        'test/schedule/export/schedule.json',
        'test/schedule/export/schedule.xcal',
        'test/schedule/export/schedule.xml',
        'test/schedule/export/schedule.ics',
        *[
            f'test/speaker/{speaker.code}/index.html'
            for speaker in slot.submission.speakers.all()
        ],
        f'test/talk/{slot.submission.code}/index.html',
        f'test/talk/{slot.submission.code}.ics',
    ]

    for path in paths:
        full_path = os.path.join(settings.HTMLEXPORT_ROOT, 'test', path)
        assert os.path.exists(full_path)

    for path in glob(os.path.join(settings.HTMLEXPORT_ROOT, 'test/media/*')):
        assert event.slug in path
        assert other_event.slug not in path

    full_path = os.path.join(settings.HTMLEXPORT_ROOT, 'test.zip')
    assert os.path.exists(full_path)

    # views and templates are the same for export and online viewing, so a naive test is enough here
    talk_html = open(
        os.path.join(
            settings.HTMLEXPORT_ROOT,
            'test',
            f'test/talk/{slot.submission.code}/index.html',
        )).read()
    assert talk_html.count(slot.submission.title) >= 2

    speaker = slot.submission.speakers.all()[0]
    speaker_html = open(
        os.path.join(settings.HTMLEXPORT_ROOT, 'test',
                     f'test/speaker/{speaker.code}/index.html')).read()
    assert speaker.name in speaker_html

    schedule_html = open(
        os.path.join(settings.HTMLEXPORT_ROOT, 'test',
                     f'test/schedule/index.html')).read()
    assert 'Contact us' in schedule_html  # locale
    assert canceled_talk.submission.title not in schedule_html

    schedule_json = json.load(
        open(
            os.path.join(settings.HTMLEXPORT_ROOT,
                         f'test/test/schedule/export/schedule.json')))
    assert schedule_json['schedule']['conference']['title'] == event.name

    schedule_ics = open(
        os.path.join(settings.HTMLEXPORT_ROOT,
                     f'test/test/schedule/export/schedule.ics')).read()
    assert slot.submission.code in schedule_ics
    assert canceled_talk.submission.code not in schedule_ics

    schedule_xcal = open(
        os.path.join(settings.HTMLEXPORT_ROOT,
                     f'test/test/schedule/export/schedule.xcal')).read()
    assert event.slug in schedule_xcal
    assert speaker.name in schedule_xcal

    schedule_xml = open(
        os.path.join(settings.HTMLEXPORT_ROOT,
                     f'test/test/schedule/export/schedule.xml')).read()
    assert slot.submission.title in schedule_xml
    assert canceled_talk.submission.frab_slug not in schedule_xml
    assert str(canceled_talk.submission.uuid) not in schedule_xml

    talk_ics = open(
        os.path.join(settings.HTMLEXPORT_ROOT,
                     f'test/test/talk/{slot.submission.code}.ics')).read()
    assert slot.submission.title in talk_ics
コード例 #36
0
 def __setattr__(self, attr, value):
     from django.test import override_settings
     override = override_settings(**{attr: value})
     override.enable()
     self._to_restore.append(override)
コード例 #37
0
def test_alert_limit_notification(rf, admin_user):
    with override_settings(
            CACHES={
                'default': {
                    'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
                    'LOCATION': 'test_configuration_cache',
                }
            }):
        cache.init_cache()

        supplier = get_simple_supplier()
        shop = get_default_shop()
        product = create_product("simple-test-product", shop, supplier)

        sc = StockCount.objects.get(supplier=supplier, product=product)
        sc.alert_limit = 10
        sc.save()

        # nothing in cache
        cache_key = AlertLimitReached.cache_key_fmt % (supplier.pk, product.pk)
        assert cache.get(cache_key) is None

        # put 11 units in stock
        supplier.adjust_stock(product.pk, +11)

        # still nothing in cache
        cache_key = AlertLimitReached.cache_key_fmt % (supplier.pk, product.pk)
        assert cache.get(cache_key) is None

        event = AlertLimitReached(product=product, supplier=supplier)
        assert event.variable_values["dispatched_last_24hs"] is False

        # stock should be 6, lower then the alert limit
        supplier.adjust_stock(product.pk, -5)
        last_run = cache.get(cache_key)
        assert last_run is not None

        event = AlertLimitReached(product=product, supplier=supplier)
        assert event.variable_values["dispatched_last_24hs"] is True

        # stock should be 1, lower then the alert limit
        supplier.adjust_stock(product.pk, -5)

        # test whether that runs inside a minute
        event = AlertLimitReached(product=product, supplier=supplier)
        event.run(shop)
        # not updated, not ran
        assert cache.get(cache_key) == last_run

        last_run -= 1000
        cache.set(cache_key, last_run)
        event = AlertLimitReached(product=product, supplier=supplier)
        event.run(shop)

        # last run should be updated
        assert cache.get(cache_key) != last_run

        event = AlertLimitReached(product=product,
                                  supplier=supplier,
                                  supplier_email="*****@*****.**",
                                  shop_email="*****@*****.**")
        assert event.variable_values["dispatched_last_24hs"] is True

        # fake we have a cache with more than 24hrs
        cache.set(cache_key, time() - (24 * 60 * 60 * 2))

        event = AlertLimitReached(product=product, supplier=supplier)
        assert event.variable_values["dispatched_last_24hs"] is False
コード例 #38
0
def test_order_flow_with_multiple_suppliers():
    cache.clear()

    shop = factories.get_default_shop()
    factories.create_default_order_statuses()
    factories.get_default_payment_method()
    factories.get_default_shipping_method()

    n_orders_pre = Order.objects.count()
    product = factories.create_product("sku", shop=shop, default_price=30)
    shop_product = product.get_shop_instance(shop)

    # Activate show supplier info for front
    assert ThemeSettings.objects.count() == 1
    theme_settings = ThemeSettings.objects.first()
    theme_settings.update_settings({"show_supplier_info": True})

    supplier_data = [
        ("Johnny Inc", 30),
        ("Mike Inc", 10),
        ("Simon Inc", 20),
    ]
    for name, product_price in supplier_data:
        supplier = Supplier.objects.create(name=name)
        shop_product.suppliers.add(supplier)
        SupplierPrice.objects.create(supplier=supplier, shop=shop, product=product, amount_value=product_price)

    strategy = "E-Commerce.testing.supplier_pricing.supplier_strategy:CheapestSupplierPriceSupplierStrategy"
    with override_settings(E-Commerce_PRICING_MODULE="supplier_pricing", E-Commerce_SHOP_PRODUCT_SUPPLIERS_STRATEGY=strategy):

        # Ok so cheapest price should be default supplier
        expected_supplier = shop_product.get_supplier()
        assert expected_supplier.name == "Mike Inc"
        with override_current_theme_class(ClassicGrayTheme, shop):  # Ensure settings is refreshed from DB
            c = SmartClient()

            # Case 1: use default supplier
            _add_to_basket(c, product.pk, 2)
            order = _complete_checkout(c, n_orders_pre + 1)
            assert order
            product_lines = order.lines.products()
            assert len(product_lines) == 1
            assert product_lines[0].supplier.pk == expected_supplier.pk
            assert product_lines[0].base_unit_price_value == decimal.Decimal("10")

            # Case 2: force supplier to Johnny Inc
            johnny_supplier = Supplier.objects.filter(name="Johnny Inc").first()
            _add_to_basket(c, product.pk, 3, johnny_supplier)
            order = _complete_checkout(c, n_orders_pre + 2)
            assert order
            product_lines = order.lines.products()
            assert len(product_lines) == 1
            assert product_lines[0].supplier.pk == johnny_supplier.pk
            assert product_lines[0].base_unit_price_value == decimal.Decimal("30")

            # Case 3: order 2 pcs from Mike and 3 pcs from Simon Inc
            mike_supplier = Supplier.objects.filter(name="Mike Inc").first()
            _add_to_basket(c, product.pk, 2, mike_supplier)

            simon_supplier = Supplier.objects.filter(name="Simon Inc").first()
            _add_to_basket(c, product.pk, 3, simon_supplier)

            order = _complete_checkout(c, n_orders_pre + 3)
            assert order
            assert order.taxful_total_price_value == decimal.Decimal("80")  # Math: 2x10e + 3x20e

            product_lines = order.lines.products()
            assert len(product_lines) == 2

            mikes_line = [line for line in product_lines if line.supplier.pk == mike_supplier.pk][0]
            assert mikes_line
            assert mikes_line.quantity == 2
            assert mikes_line.base_unit_price_value == decimal.Decimal("10")

            simon_line = [line for line in product_lines if line.supplier.pk == simon_supplier.pk][0]
            assert simon_line
            assert simon_line.quantity == 3
            assert simon_line.base_unit_price_value == decimal.Decimal("20")
コード例 #39
0
def test_parler_language_code(setting_key, value, should_raise):
    kwargs = {setting_key: value}
    with override_settings(**kwargs):
        if should_raise:
            with pytest.raises(MissingSettingException):
                apps.get_app_config("shuup").ready()
コード例 #40
0
ファイル: utils.py プロジェクト: virtengine/ve-waldur-v2
def override_plugin_settings(**kwargs):
    plugin_settings = copy.deepcopy(settings.WALDUR_VMWARE)
    plugin_settings.update(kwargs)
    return override_settings(WALDUR_VMWARE=plugin_settings)
コード例 #41
0
    def test_do_service_m12(self):
        res = self.client.get(self.gb_m12.get_absolute_url())

        self.assertContains(
            res,
            '<option selected value="2017-01-01">Sunday 1 January 2017</option>'
        )

        groupings = res.context_data['timetable'].groupings
        outbound_stops = [str(row.part.stop) for row in groupings[0].rows]
        inbound_stops = [str(row.part.stop) for row in groupings[1].rows]
        self.assertEqual(outbound_stops, [
            'Belgravia Victoria Coach Station',
            '049004705400',
            'Rugby ASDA',
            'Fosse Park ASDA',
            'Loughborough Holywell Way',
            'Nottingham Broad Marsh Bus Station',
            'Meadowhall Interchange',
            'Leeds City Centre York Street',
            'Bradford City Centre Hall Ings',
            'Huddersfield Town Centre Market Street',
            'Leeds City Centre Bus Stn',
            'Shudehill Interchange',
            'Middlesbrough Bus Station Express Lounge',
            'Sunderland Interchange',
            'Newcastle upon Tyne John Dobson Street',
        ])
        self.assertEqual(inbound_stops, [
            'Huddersfield Town Centre Market Street',
            'Bradford City Centre Interchange',
            'Newcastle upon Tyne John Dobson Street', 'Sunderland Interchange',
            'Middlesbrough Bus Station Express Lounge',
            'Leeds City Centre Bus Stn', 'Shudehill Interchange',
            'Leeds City Centre York Street', 'Meadowhall Interchange',
            'Nottingham Broad Marsh Bus Station', 'Loughborough Holywell Way',
            'Fosse Park ASDA', 'Rugby ASDA', '049004705400',
            'Victoria Coach Station Arrivals'
        ])

        with override_settings(TNDS_DIR='this is not a directory'):
            # should not be cached (because dummy cache)
            with override_settings(
                    CACHES={
                        'default': {
                            'BACKEND':
                            'django.core.cache.backends.dummy.DummyCache'
                        }
                    }):
                res = self.client.get(self.gb_m12.get_absolute_url())
            self.assertIsNone(res.context_data['timetable'])

            # should be cached
            res = self.client.get(self.gb_m12.get_absolute_url())
            self.assertEqual('2017-01-01',
                             str(res.context_data['timetable'].date))

            # should be cached (even though different date)
            res = self.client.get(self.gb_m12.get_absolute_url() +
                                  '?date=2017-01-02')
            self.assertEqual('2017-01-02',
                             str(res.context_data['timetable'].date))
コード例 #42
0
        self.assertEqual(response.template_name,
                         ('tests/test_views_list/listviewtest/queue.html',
                          'viewflow/flow/queue.html'))


class ListViewTestFlow(Flow):
    start1 = flow.StartFunction().Next(this.test_task)
    start2 = flow.Start(lambda request: None).Permission(
        'auth.start_flow_perm').Next(this.test_task)
    start3 = flow.Start(lambda request: None).Next(this.test_task)
    test_task = flow.View(lambda request: None).Next(this.end)
    end = flow.End()


urlpatterns = [
    url(
        r'^test/',
        include(viewset.FlowViewSet(ListViewTestFlow).urls,
                namespace='listviewtest'))
]

try:
    from django.test import override_settings
    Test = override_settings(ROOT_URLCONF=__name__)(Test)
except ImportError:
    """
    django 1.6
    """
    Test.urls = __name__
コード例 #43
0
 def test_loading_class_from_module_not_defined_in_local_app(self):
     with override_settings(INSTALLED_APPS=self.installed_apps):
         (Repository, ) = get_classes('shipping.repository',
                                      ('Repository', ))
         self.assertEqual('oscar.apps.shipping.repository',
                          Repository.__module__)
コード例 #44
0
def test_anon_disabling():
    with override_settings(SHUUP_ALLOW_ANONYMOUS_ORDERS=False):
        with pytest.raises(ValidationError):
            order = create_empty_order()
            order.save()
コード例 #45
0
def test_discount_admin_list_view(rf, admin_user):
    with override_settings(SHUUP_ENABLE_MULTIPLE_SHOPS=True):
        for x in range(3):
            _test_discount_list_view(rf, x)

        # Superuser gets same data as shop staff
        shop = Shop.objects.exclude(
            identifier=factories.DEFAULT_IDENTIFIER).order_by("?").first()
        request = apply_request_middleware(rf.get(
            "/", {"jq": json.dumps({
                "perPage": 100,
                "page": 1
            })}),
                                           user=admin_user,
                                           shop=shop)
        set_shop(request, shop)
        view_instance = DiscountListView()
        view_instance.request = request
        data = json.loads(view_instance.get(request).content.decode("UTF-8"))
        assert len(data["items"]) == 4

        # In active 3 discounts to see that those are filtered out
        payload = {
            "action":
            "archive_discounts",
            "values": [
                discount.pk for discount in Discount.objects.filter(
                    shops=shop).order_by("?")[:3]
            ]
        }
        archive_request = apply_request_middleware(rf.post("/"),
                                                   user=admin_user,
                                                   shop=shop)
        set_shop(archive_request, shop)
        archive_request._body = json.dumps(payload).encode("UTF-8")
        view = DiscountListView.as_view()
        response = view(request=archive_request)
        if hasattr(response, "render"):
            response.render()

        assert response.status_code == 200
        assert Discount.objects.available(shop).count() == 1

        data = json.loads(view_instance.get(request).content.decode("UTF-8"))
        assert len(data["items"]) == 1

        # Archived list should now show 3 results
        archived_view_instance = ArchivedDiscountListView()
        archived_view_instance.request = request
        data = json.loads(
            archived_view_instance.get(request).content.decode("UTF-8"))
        assert len(data["items"]) == 3

        # Make sure rendering this archived discounts list works
        view_func = ArchivedDiscountListView.as_view()
        request = apply_request_middleware(rf.get("/"),
                                           user=admin_user,
                                           shop=shop)
        set_shop(request, shop)
        response = view_func(request)
        if hasattr(response, "render"):
            response.render()

        assert response.status_code == 200

        # Unarchive all discounts
        payload = {"action": "unarchive_discounts", "values": "all"}
        unarchive_request = apply_request_middleware(rf.post("/"),
                                                     user=admin_user,
                                                     shop=shop)
        set_shop(unarchive_request, shop)
        unarchive_request._body = json.dumps(payload).encode("UTF-8")
        view = ArchivedDiscountListView.as_view()
        response = view(request=unarchive_request)
        if hasattr(response, "render"):
            response.render()

        assert response.status_code == 200
        assert Discount.objects.available(shop).count() == 4

        # Re-archive all discounts
        payload = {"action": "archive_discounts", "values": "all"}
        archive_request = apply_request_middleware(rf.post("/"),
                                                   user=admin_user,
                                                   shop=shop)
        set_shop(archive_request, shop)
        archive_request._body = json.dumps(payload).encode("UTF-8")
        view = DiscountListView.as_view()
        response = view(request=archive_request)
        if hasattr(response, "render"):
            response.render()

        assert response.status_code == 200
        assert Discount.objects.available(shop).count() == 0

        # Unarchive just one discount
        payload = {
            "action":
            "unarchive_discounts",
            "values": [
                discount.pk for discount in Discount.objects.filter(
                    shops=shop).order_by("?")[:1]
            ]
        }
        unarchive_request = apply_request_middleware(rf.post("/"),
                                                     user=admin_user,
                                                     shop=shop)
        set_shop(unarchive_request, shop)
        unarchive_request._body = json.dumps(payload).encode("UTF-8")
        view = ArchivedDiscountListView.as_view()
        response = view(request=unarchive_request)
        if hasattr(response, "render"):
            response.render()

        assert response.status_code == 200
        assert Discount.objects.available(shop).count() == 1

        # Delete one archived discount
        payload = {
            "action":
            "delete_discounts",
            "values": [
                discount.pk for discount in Discount.objects.archived(
                    shop).order_by("?")[:1]
            ]
        }
        delete_request = apply_request_middleware(rf.post("/"),
                                                  user=admin_user,
                                                  shop=shop)
        set_shop(delete_request, shop)
        delete_request._body = json.dumps(payload).encode("UTF-8")
        view = ArchivedDiscountListView.as_view()
        response = view(request=delete_request)
        if hasattr(response, "render"):
            response.render()

        assert response.status_code == 200
        assert Discount.objects.filter(shops=shop).count() == 3

        # Delete all for this shop only
        payload = {"action": "delete_discounts", "values": "all"}
        delete_request = apply_request_middleware(rf.post("/"),
                                                  user=admin_user,
                                                  shop=shop)
        set_shop(delete_request, shop)
        delete_request._body = json.dumps(payload).encode("UTF-8")
        view = ArchivedDiscountListView.as_view()
        response = view(request=delete_request)
        if hasattr(response, "render"):
            response.render()

        assert response.status_code == 200
        assert Discount.objects.filter(shops=shop).count(
        ) == 1  # Since only archived can be deleted with mass action
        assert Discount.objects.available(shop).count() == 1
        assert Discount.objects.archived(shop).count() == 0
        assert Discount.objects.count() == 9
コード例 #46
0
ファイル: tests.py プロジェクト: Lifedrama/python
 def test_override(self):
     self.assertFalse(settings.is_overridden('ALLOWED_HOSTS'))
     with override_settings(ALLOWED_HOSTS=[]):
         self.assertTrue(settings.is_overridden('ALLOWED_HOSTS'))
コード例 #47
0
ファイル: test_liveserver.py プロジェクト: zzjeric/django
 def setUpClass(cls):
     # Override settings
     cls.settings_override = override_settings(**TEST_SETTINGS)
     cls.settings_override.enable()
     super(LiveServerBase, cls).setUpClass()
コード例 #48
0
ファイル: test_happy_hours.py プロジェクト: kafura0/OranKids
def test_happy_hour_prices_expiration(rf):
    with override_settings(
            CACHES={
                'default': {
                    'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
                    'LOCATION': 'test_happy_hour_prices_bump',
                }
            }):
        happy_hour = init_test()

        # it is now: 2018-01-01 09:00 AM
        before_happy_hour = datetime.datetime(2018,
                                              1,
                                              1,
                                              9,
                                              0,
                                              tzinfo=pytz.UTC)  # 09:00 AM
        inside_happy_hour = datetime.datetime(2018,
                                              1,
                                              1,
                                              10,
                                              30,
                                              tzinfo=pytz.UTC)  # 10:30 AM
        after_happy_hours = datetime.datetime(2018,
                                              1,
                                              1,
                                              11,
                                              20,
                                              tzinfo=pytz.UTC)  # 11:30 AM

        # Create condition from 10am to 11am
        hour_start = datetime.datetime(2018, 1, 1, 10, 0,
                                       tzinfo=pytz.UTC).time()  # 10:00 AM
        hour_end = datetime.datetime(2018, 1, 1, 11, 0,
                                     tzinfo=pytz.UTC).time()  # 11:00 AM
        set_valid_times_condition(happy_hour, hour_start, hour_end,
                                  str(before_happy_hour.weekday()))

        shop = happy_hour.shops.first()
        discount = happy_hour.discounts.first()
        product = discount.product
        shop_product = product.get_shop_instance(shop)
        assert shop_product.default_price_value == 10
        assert discount.discounted_price_value == 6

        def get_request():
            return apply_request_middleware(rf.get("/"))

        price_template = engines["jinja2"].from_string("{{ product|price }}")
        is_discounted_template = engines["jinja2"].from_string(
            "{{ product|is_discounted }}")
        discount_percent_template = engines["jinja2"].from_string(
            "{{ product|discount_percent }}")

        # we start with time being before happy hour
        with patch("django.utils.timezone.now", new=lambda: before_happy_hour):
            # mock also time.time so the cache timeout will be calculated correctly
            with patch("time.time",
                       new=lambda: to_timestamp(before_happy_hour)):
                # check that product price is still the orignal (€10.00)
                # run twice to make sure caches are being used
                for cache_test in range(2):
                    context = dict(product=product, request=get_request())
                    assert price_template.render(context) == format_money(
                        shop_product.default_price)
                    assert is_discounted_template.render(context) == "False"
                    assert discount_percent_template.render(context) == "0%"

                    if cache_test == 1:
                        assert get_cached_price_info(
                            get_request(),
                            product,
                            1,
                            supplier=shop_product.get_supplier())

        # now we are inside happy hour range
        with patch("django.utils.timezone.now", new=lambda: inside_happy_hour):
            # mock also time.time so the cache timeout will be calculated correctly
            with patch("time.time",
                       new=lambda: to_timestamp(inside_happy_hour)):
                # check that product price is the discounted one (€6.00)
                # run twice to make sure caches are being used
                for cache_test in range(2):
                    context = dict(product=product, request=get_request())
                    assert price_template.render(context) == format_money(
                        shop.create_price(discount.discounted_price_value))
                    assert is_discounted_template.render(context) == "True"
                    assert discount_percent_template.render(context) == "40%"

                    if cache_test == 1:
                        assert get_cached_price_info(
                            get_request(),
                            product,
                            1,
                            supplier=shop_product.get_supplier())

                # we change the discounted price from $6 to $7
                # cached should be bumped
                discount.discounted_price_value = 7
                discount.save()
                for cache_test in range(2):
                    context = dict(product=product, request=get_request())
                    assert price_template.render(context) == format_money(
                        shop.create_price(discount.discounted_price_value))
                    assert is_discounted_template.render(context) == "True"
                    assert discount_percent_template.render(context) == "30%"

                    if cache_test == 1:
                        assert get_cached_price_info(
                            get_request(),
                            product,
                            1,
                            supplier=shop_product.get_supplier())

        # now we are inside happy hour range
        with patch("django.utils.timezone.now", new=lambda: after_happy_hours):
            # mock also time.time so the cache timeout will be calculated correctly
            with patch("time.time",
                       new=lambda: to_timestamp(after_happy_hours)):
                # check that product price is the orignal (€10.00)
                # run twice to make sure caches are being used
                for cache_test in range(2):
                    context = dict(product=product, request=get_request())
                    assert price_template.render(context) == format_money(
                        shop_product.default_price)
                    assert is_discounted_template.render(context) == "False"
                    assert discount_percent_template.render(context) == "0%"

                    if cache_test == 1:
                        assert get_cached_price_info(
                            get_request(),
                            product,
                            1,
                            supplier=shop_product.get_supplier())
コード例 #49
0
ファイル: test_filefield.py プロジェクト: zybxhwh/django
 def test_media_root_pathlib(self):
     with tempfile.TemporaryDirectory() as tmp_dir:
         with override_settings(MEDIA_ROOT=Path(tmp_dir)):
             with TemporaryUploadedFile('foo.txt', 'text/plain', 1, 'utf-8') as tmp_file:
                 Document.objects.create(myfile=tmp_file)
                 self.assertTrue(os.path.exists(os.path.join(tmp_dir, 'unused', 'foo.txt')))
コード例 #50
0
ファイル: test_happy_hours.py プロジェクト: kafura0/OranKids
def test_happy_hour(rf):
    happy_hour = init_test()

    discount = happy_hour.discounts.first()
    shop = discount.shops.first()
    assert Discount.objects.available().count() == 1
    assert Discount.objects.available(shop).count() == 1

    w_today = timezone.now().date().weekday()
    w_tomorrow = (timezone.now() + datetime.timedelta(days=1)).date().weekday()
    w_future = (timezone.now() + datetime.timedelta(days=2)).date().weekday()
    matching_days = ",".join(map(str, [w_today]))
    non_matching_days = ",".join(map(str, [w_tomorrow, w_future]))

    # Matching time range
    hour_start = (timezone.now() -
                  datetime.timedelta(hours=2)).time()  # 8:00 AM
    hour_end = (timezone.now() +
                datetime.timedelta(hours=2)).time()  # 12:00 PM
    set_valid_times_condition(happy_hour, hour_start, hour_end, matching_days)
    assert Discount.objects.available().count() == 1
    assert Discount.objects.available(shop).count() == 1

    set_valid_times_condition(happy_hour, hour_start, hour_end,
                              non_matching_days)
    assert Discount.objects.available().count() == 0
    assert Discount.objects.available(shop).count() == 0

    # Hour end shouldn't cause a match. Should be obvious that if the
    # merchant set start time 8:00 AM and end time 10:00 AM th campaign is no more
    # at 10:10 AM
    new_hour_start = (timezone.now() -
                      datetime.timedelta(hours=2)).time()  # 8:00 AM
    new_hour_end = timezone.now().time()  # 10:00 PM
    set_valid_times_condition(happy_hour, new_hour_start, new_hour_end,
                              non_matching_days)
    assert Discount.objects.available().count() == 0
    assert Discount.objects.available(shop).count() == 0

    # time in future shouldn't match
    new_hour_start = (timezone.now() +
                      datetime.timedelta(hours=2)).time()  # 12:00 PM
    new_hour_end = (timezone.now() +
                    datetime.timedelta(hours=4)).time()  # 14:00 PM
    set_valid_times_condition(happy_hour, new_hour_start, new_hour_end,
                              matching_days)
    assert Discount.objects.available().count() == 0
    assert Discount.objects.available(shop).count() == 0

    # time in past shouldn't match
    new_hour_start = (timezone.now() -
                      datetime.timedelta(hours=3)).time()  # 7:00 AM
    new_hour_end = (timezone.now() -
                    datetime.timedelta(hours=2)).time()  # 8:00 AM
    set_valid_times_condition(happy_hour, new_hour_start, new_hour_end,
                              matching_days)
    assert Discount.objects.available().count() == 0
    assert Discount.objects.available(shop).count() == 0

    # Special times (should match)
    new_hour_start = timezone.now().time()  # 10:00 AM
    new_hour_end = (timezone.now() +
                    datetime.timedelta(hours=14)).time()  # 0:00 AM
    set_valid_times_condition(happy_hour, new_hour_start, new_hour_end,
                              matching_days)
    assert Discount.objects.available().count() == 1
    assert Discount.objects.available(shop).count() == 1

    set_valid_times_condition(happy_hour, new_hour_start, new_hour_end,
                              non_matching_days)
    assert Discount.objects.available().count() == 0
    assert Discount.objects.available(shop).count() == 0

    # Special times (should not match)
    new_hour_start = (timezone.now() +
                      datetime.timedelta(hours=2)).time()  # 12:00 AM
    new_hour_end = (timezone.now() +
                    datetime.timedelta(hours=14)).time()  # 0:00 AM
    set_valid_times_condition(happy_hour, new_hour_start, new_hour_end,
                              matching_days)
    assert Discount.objects.available().count() == 0
    assert Discount.objects.available(shop).count() == 0

    # Lastly few timezone tests (LA it is monday and time is 2:00 AM.)
    with override_settings(TIME_ZONE="America/Los_Angeles"):
        # So the 10:00 AM shouldn't match at all
        new_hour_start = (timezone.now() -
                          datetime.timedelta(hours=1)).time()  # 9:00 AM
        new_hour_end = (timezone.now() +
                        datetime.timedelta(hours=1)).time()  # 11:00 AM
        set_valid_times_condition(happy_hour, new_hour_start, new_hour_end,
                                  matching_days)
        assert Discount.objects.available().count() == 0
        assert Discount.objects.available(shop).count() == 0

        # Instead around 2:00 AM we will find a match
        new_hour_start = (timezone.now() -
                          datetime.timedelta(hours=9)).time()  # 1:00 AM
        new_hour_end = (timezone.now() -
                        datetime.timedelta(hours=7)).time()  # 3:00 AM
        set_valid_times_condition(happy_hour, new_hour_start, new_hour_end,
                                  matching_days)
        assert Discount.objects.available().count() == 1
        assert Discount.objects.available(shop).count() == 1

        # Make sure that the hour end doesn't cause match
        new_hour_start = (timezone.now() -
                          datetime.timedelta(hours=9)).time()  # 1:00 AM
        new_hour_end = (timezone.now() -
                        datetime.timedelta(hours=8)).time()  # 2:00 AM
        set_valid_times_condition(happy_hour, new_hour_start, new_hour_end,
                                  matching_days)
        assert Discount.objects.available().count() == 0
        assert Discount.objects.available(shop).count() == 0
コード例 #51
0
def _populate_applied_attribute(aa):
    if aa.attribute.type == AttributeType.BOOLEAN:
        aa.value = True
        aa.save()
        assert aa.value is True, "Truth works"
        assert aa.untranslated_string_value == "1", "Integer attributes save string representations"
        aa.value = not 42  # (but it could be something else)
        aa.save()
        assert aa.value is False, "Lies work"
        assert aa.untranslated_string_value == "0", "Integer attributes save string representations"
        aa.value = None
        aa.save()
        assert aa.value is None, "None works"
        assert aa.untranslated_string_value == "", "Boolean saves None"
        return

    if aa.attribute.type == AttributeType.INTEGER:
        aa.value = 320.51
        aa.save()
        assert aa.value == 320, "Integer attributes get rounded down"
        assert aa.untranslated_string_value == "320", "Integer attributes save string representations"
        return

    if aa.attribute.type == AttributeType.DECIMAL:
        aa.value = Decimal("0.636")  # Surface pressure of Mars
        aa.save()
        assert aa.value * 1000 == 636, "Decimals work like they should"
        assert aa.untranslated_string_value == "0.636", "Decimal attributes save string representations"
        return

    if aa.attribute.type == AttributeType.TIMEDELTA:
        aa.value = 86400
        aa.save()
        assert aa.value.days == 1, "86,400 seconds is one day"
        assert aa.untranslated_string_value == "86400", "Timedeltas are seconds as strings"

        aa.value = datetime.timedelta(days=4)
        aa.save()
        assert aa.value.days == 4, "4 days remain as 4 days"
        assert aa.untranslated_string_value == "345600", "Timedeltas are still seconds as strings"
        return

    if aa.attribute.type == AttributeType.UNTRANSLATED_STRING:
        aa.value = "Dog Hello"
        aa.save()
        assert aa.value == "Dog Hello", "Untranslated strings work"
        assert aa.untranslated_string_value == "Dog Hello", "Untranslated strings work"
        return

    if aa.attribute.type == AttributeType.TRANSLATED_STRING:
        assert aa.attribute.is_translated
        with override_settings(LANGUAGES=[(x, x)
                                          for x in ("en", "fi", "ga", "ja")]):
            versions = {
                "en": "science fiction",
                "fi": "tieteiskirjallisuus",
                "ga": "ficsean eolaíochta",
                "ja": "空想科学小説",
            }
            for language_code, text in versions.items():
                aa.set_current_language(language_code)
                aa.value = text
                aa.save()
                assert aa.value == text, "Translated strings work"
            for language_code, text in versions.items():
                assert aa.safe_translation_getter(
                    "translated_string_value",
                    language_code=language_code) == text, (
                        "%s translation is safe" % language_code)

            aa.set_current_language("xx")
            assert aa.value == "", "untranslated version yields an empty string"

        return

    if aa.attribute.type == AttributeType.DATE:
        aa.value = "2014-01-01"
        assert aa.value == datetime.date(2014, 1, 1), "Date parsing works"
        assert aa.untranslated_string_value == "2014-01-01", "Dates are saved as strings"
        return

    if aa.attribute.type == AttributeType.DATETIME:
        with pytest.raises(TypeError):
            aa.value = "yesterday"
        dt = datetime.datetime(1997, 8, 12, 14)
        aa.value = dt
        assert aa.value.toordinal() == 729248, "Date assignment works"
        assert aa.value.time().hour == 14, "The clock still works"
        assert aa.untranslated_string_value == dt.isoformat(
        ), "Datetimes are saved as strings too"
        return

    raise NotImplementedError("Error! Not implemented: populating %s" %
                              aa.attribute.type)  # pragma: no cover
コード例 #52
0
ファイル: test_timezone.py プロジェクト: Birama0810/Django
 def test_get_default_timezone_utc(self):
     with override_settings(USE_TZ=True, TIME_ZONE='UTC'):
         self.assertIs(timezone.get_default_timezone(), timezone.utc)
コード例 #53
0
    def test_one_locale(self):
        with override_settings(LOCALE_PATHS=[os.path.join(self.test_dir, 'locale')]):
            call_command('compilemessages', locale=['hr'], stdout=StringIO())

            self.assertTrue(os.path.exists(self.MO_FILE_HR))
コード例 #54
0
ファイル: test_timezone.py プロジェクト: Birama0810/Django
 def test_now(self):
     with override_settings(USE_TZ=True):
         self.assertTrue(timezone.is_aware(timezone.now()))
     with override_settings(USE_TZ=False):
         self.assertTrue(timezone.is_naive(timezone.now()))
コード例 #55
0
 def setUp(self):
     self.settings_override = override_settings(
         EMAIL_BACKEND=self.email_backend)
     self.settings_override.enable()
コード例 #56
0
def test_discount_admin_delete_view(rf):
    with override_settings(SHUUP_ENABLE_MULTIPLE_SHOPS=True):
        for x in range(3):
            _test_exception_delete_view(rf, x)
コード例 #57
0
ファイル: test_loader.py プロジェクト: guyi2020/blog
 def test_load_import_error(self):
     with override_settings(MIGRATION_MODULES={"migrations": "import_error_package"}):
         with self.assertRaises(ImportError):
             MigrationLoader(connection)
コード例 #58
0
def test_order_refunds_with_multiple_suppliers():
    shop = get_default_shop()
    supplier1 = Supplier.objects.create(identifier="1", name="supplier1")
    supplier1.shops.add(shop)
    supplier2 = Supplier.objects.create(identifier="2")
    supplier2.shops.add(shop)
    supplier3 = Supplier.objects.create(identifier="3", name="s")
    supplier3.shops.add(shop)

    product1 = create_product("sku1", shop=shop, default_price=10)
    shop_product1 = product1.get_shop_instance(shop=shop)
    shop_product1.suppliers = [supplier1, supplier2, supplier3]

    product2 = create_product("sku2", shop=shop, default_price=10)
    shop_product2 = product1.get_shop_instance(shop=shop)
    shop_product2.suppliers = [supplier1, supplier2]

    product3 = create_product("sku3",
                              shop=shop,
                              default_price=10,
                              shipping_mode=ShippingMode.NOT_SHIPPED)
    shop_product3 = product1.get_shop_instance(shop=shop)
    shop_product3.suppliers = [supplier3]

    product_quantities = {
        supplier1: {
            product1: 5,
            product2: 6
        },
        supplier2: {
            product1: 3,
            product2: 13
        },
        supplier3: {
            product1: 1,
            product3: 50
        }
    }

    def get_quantity(supplier, product):
        return product_quantities[supplier.pk][product.pk]

    order = create_empty_order(shop=shop)
    order.full_clean()
    order.save()

    for supplier, product_data in six.iteritems(product_quantities):
        for product, quantity in six.iteritems(product_data):
            add_product_to_order(order, supplier, product, quantity, 5)

    # Lines without quantity shouldn't affect refunds
    other_line = OrderLine(order=order,
                           type=OrderLineType.OTHER,
                           text="This random line for textual information",
                           quantity=0)
    other_line.save()
    order.lines.add(other_line)

    order.cache_prices()
    order.create_payment(order.taxful_total_price)
    assert order.is_paid()

    # All supplier should be able to refund the order
    assert order.can_create_refund()
    assert order.can_create_refund(supplier1)
    assert order.can_create_refund(supplier2)
    assert order.can_create_refund(supplier3)

    assert order.get_total_unrefunded_amount(supplier1).value == Decimal(
        "55")  # 11 * 5
    assert order.get_total_unrefunded_quantity(supplier1) == Decimal(
        "11")  # 5 x product1 and 6 x product2

    with pytest.raises(RefundExceedsAmountException):
        order.create_refund([{
            "line": "amount",
            "quantity": 1,
            "amount": order.shop.create_price(60)
        }],
                            supplier=supplier1)

    # Supplier 1 refunds the order
    order.create_refund(_get_refund_data(order, supplier1))
    assert order.get_total_refunded_amount(supplier1).value == Decimal(
        "55")  # 11 * 5
    assert order.get_total_unrefunded_amount(supplier1).value == Decimal("0")

    assert not order.can_create_refund(supplier1)
    assert order.can_create_refund()
    assert order.can_create_refund(supplier2)
    assert order.can_create_refund(supplier3)

    assert order.get_total_unrefunded_amount(supplier2).value == Decimal(
        "80")  # 16 * 5
    assert order.get_total_unrefunded_quantity(supplier2) == Decimal(
        "16")  # 3 x product1 and 13 x product2

    with pytest.raises(RefundExceedsAmountException):
        order.create_refund([{
            "line": "amount",
            "quantity": 1,
            "amount": order.shop.create_price(81)
        }],
                            supplier=supplier2)

    # Supplier 2 refunds the order
    order.create_refund(_get_refund_data(order, supplier2))
    assert order.get_total_refunded_amount(supplier2).value == Decimal(
        "80")  # 11 * 5
    assert order.get_total_unrefunded_amount(supplier2).value == Decimal("0")
    assert not order.can_create_refund(supplier1)
    assert not order.can_create_refund(supplier2)
    assert order.can_create_refund()
    assert order.can_create_refund(supplier3)

    assert order.get_total_unrefunded_amount(supplier3).value == Decimal(
        "255")  # 51 * 5
    assert order.get_total_unrefunded_quantity(supplier3) == Decimal(
        "51")  # 3 x product1 and 13 x product2

    with override_settings(SHUUP_ALLOW_ARBITRARY_REFUNDS=False):
        with pytest.raises(RefundArbitraryRefundsNotAllowedException):
            order.create_refund([{
                "line": "amount",
                "quantity": 1,
                "amount": order.shop.create_price(200)
            }],
                                supplier=supplier3)

    order.create_refund([{
        "line": "amount",
        "quantity": 1,
        "amount": order.shop.create_price(200)
    }],
                        supplier=supplier3)
    assert OrderLine.objects.filter(order=order,
                                    supplier=supplier3,
                                    type=OrderLineType.REFUND).exists()

    # Supplier 3 refunds the order
    order.create_refund(_get_refund_data(order, supplier3))
    assert order.get_total_refunded_amount(supplier3).value == Decimal(
        "255")  # 11 * 5
    assert order.get_total_unrefunded_amount(supplier3).value == Decimal("0")
    assert not order.can_create_refund(supplier1)
    assert not order.can_create_refund(supplier2)
    assert not order.can_create_refund(supplier3)
    assert not order.can_create_refund()
コード例 #59
0
from ..mails import DefaultLayout

API_BASE_PATH = '/api/'

User = get_user_model()

integration_test = pytest.mark.skipif(os.environ.get('NO_INTEGRATION',
                                                     None) == '1',
                                      reason='skip integration test')
skip_ci_test = pytest.mark.skipif(os.environ.get('SKIP_CI_TEST', None) == '1',
                                  reason='skip ci test')

ignore_external = override_settings(
    FIREBASE_SKIP=True,
    STRIPE_SKIP=True,
    EMAIL_SKIP=True,
    ROBUST_ALWAYS_EAGER=True,
)


class JsonClient(Client):
    def _make_path(self, path):
        if not path.startswith('/api/'):
            return '{}{}'.format(API_BASE_PATH, path)
        return path

    def _json_request(self, method, path, data, secure=False, **extra):
        method = method.lower()
        assert method in {
            'delete', 'get', 'head', 'options', 'patch', 'post', 'put'
        }
コード例 #60
0
 def test_loading_class_which_is_not_defined_in_local_module(self):
     with override_settings(INSTALLED_APPS=self.installed_apps):
         (FixedPrice, ) = get_classes('shipping.methods', ('FixedPrice', ))
         self.assertEqual('oscar.apps.shipping.methods',
                          FixedPrice.__module__)