Produits Entr'ouvert » Combo

    def add_arguments(self, parser):

        parser.add_argument(

                '--output', metavar='FILE', default=None,

                help='name of a file to write output to')

        parser.add_argument(

                '--format-json', action='store_true', default=False,

                help='use JSON format with no asset files')

    def handle(self, *args, **options):

            else:

        else:

                try:

                except IOError as e:

                    raise CommandError(e)

            else:

                raise CommandError(_('TAR format require output filename parameter'))

            except IndexError:

                raise ImportSiteError(message)

            raise ImportSiteError(_('Unknown page "%s".') % page_slug)

def export_site_tar(fd, export_kwargs=None):

    tar = tarfile.open(mode='w', fileobj=fd)

    data = export_site(**(export_kwargs or {}))

    add_tar_content(tar, '_site.json', json.dumps(data, indent=2))

    tar.close()

def import_site_tar(fd, if_empty=False, clean=False, overwrite=False, request=None):

    tar = tarfile.open(mode='r', fileobj=fd)

    try:

        tarinfo = tar.getmember('_site.json')

    except KeyError:

    clean_assets_files()

    assert count_asset_files() == 0

    clean_assets_files()

def test_assets_export_size_view(app, some_assets):

    resp = app.get(reverse('combo-manager-assets-export-size'))

    assert resp.text.split() == ['(9', 'bytes)']

    cell.save()

@pytest.fixture

def some_map_layers():

    MapLayer(label='Foo', slug='foo', geojson_url='http://example.net/foo/').save()

    MapLayer(label='Bar', slug='bar', geojson_url='http://example.net/bar/').save()

@pytest.fixture

def some_assets():

    Asset(key='banner', asset=File(BytesIO(b'test'), 'test.png')).save()

    Asset(key='favicon', asset=File(BytesIO(b'test2'), 'test2.png')).save()

def get_output_of_command(command, *args, **kwargs):

    old_stdout = sys.stdout

    output = sys.stdout = StringIO()

    sys.stdout = old_stdout

    return output.getvalue()

def test_import_export(app, some_data):

    assert len(json.loads(output)['pages']) == 3

    import_site(data={}, clean=True)

    assert Page.objects.all().count() == 0

    assert TextCell.objects.all().count() == 0

    assert len(json.loads(empty_output)['pages']) == 0

    Page(title='test', slug='test').save()

    old_stdin = sys.stdin

    sys.stdin = StringIO(json.dumps({}))

    assert Page.objects.count() == 1

    try:

        call_command('import_site', '-', clean=True)

    assert TextCell.objects.all().count() == 1

    import_site(data={}, if_empty=True)

    assert Page.objects.count() == 3

    assert TextCell.objects.all().count() == 1

    import_site(data=[], clean=True)

    tempdir = tempfile.mkdtemp('chrono-test')

    assert os.path.exists(os.path.join(tempdir, 't.json'))

    shutil.rmtree(tempdir)

def test_import_export_with_parent(app, some_data):

    payload = json.loads(output)

    payload['pages'][1]['fields']['parent'] = ['one']

    Page.objects.all().delete()

    import_site(data=payload)

    assert Page.objects.count() == 3

    two = Page.objects.get(slug='two')

    assert two.parent.slug == 'one'

def test_import_export_with_unknown_parent(app, some_data):

    payload = json.loads(output)

    payload['pages'][0]['fields']['exclude_from_navigation'] = False

    payload['pages'][0]['fields']['parent'] = ['unknown-parent']

    Page.objects.all().delete()

    import_site(data=payload)

    assert Page.objects.count() == 3

def test_backward_compatibility_import(app, some_data):

    old_export = Page.export_all_for_json()

    Page.objects.all().delete()

    import_site(data=old_export)

    assert Page.objects.count() == 3

def test_import_export_map_layers(app, some_map_layers):

    assert len(json.loads(output)['map-layers']) == 2

    import_site(data={}, clean=True)

    assert MapLayer.objects.all().count() == 0

    assert len(json.loads(empty_output)['map-layers']) == 0

    MapLayer(label='Baz', slug='baz', geojson_url='http://example.net/baz/').save()

    old_stdin = sys.stdin

    sys.stdin = StringIO(json.dumps({}))

    assert MapLayer.objects.count() == 1

    try:

        call_command('import_site', '-', clean=True)

    assert MapLayer.objects.count() == 2

def test_import_export_map_cells(app, some_data, some_map_layers):

    page = Page.objects.get(slug='one')

    cell = Map(page=page, order=0, placeholder='content')

    cell.save()

    MapLayerOptions.objects.create(map_cell=cell, map_layer=MapLayer.objects.get(slug='foo'))

    import_site(data={}, clean=True)

    assert Map.objects.count() == 0

    assert MapLayer.objects.count() == 0

    site_data = json.loads(site_export)

    import_site(data=site_data, clean=True)

    assert Map.objects.count() == 1

    assert MapLayer.objects.filter(slug='foo').exists() is True

    page = Page.objects.get(slug='one')

    page.groups.set([group])

    page.save()

    cell = TextCell.objects.get(order=0)

    cell.groups.set([group])

    cell.save()

    assert len(json.loads(output)['pages']) == 3

    import_site(data={}, clean=True)

    assert Page.objects.all().count() == 0

    assert TextCell.objects.all().count() == 0

    Group.objects.all().delete()

    with pytest.raises(MissingGroups) as excinfo:

    assert TextCell.objects.all().count() == 1

    page = Page.objects.get(slug='one')

    assert [x.name for x in page.groups.all()] == ['A Group']

    cell = TextCell.objects.get(order=0)

    assert [x.name for x in cell.groups.all()] == ['A Group']

def test_import_export_assets(app, some_assets):

    assert len(json.loads(output)['assets']) == 2

    import_site(data={}, clean=True)

    assert Asset.objects.all().count() == 0

    assert len(json.loads(empty_output)['assets']) == 0

    Asset(key='footer', asset=File(StringIO('test3'), 'test3.png')).save()

    old_stdin = sys.stdin

    sys.stdin = StringIO(json.dumps({}))

    assert Asset.objects.count() == 1

    try:

        call_command('import_site', '-', clean=True)

        f.flush()

        call_command('import_site', f.name)

    assert Asset.objects.count() == 2

    import_site(data={}, if_empty=True)

    assert Asset.objects.count() == 2

def test_import_export_pwa_settings(app):

    pwa_settings = PwaSettings.singleton()

    pwa_settings.offline_text = 'Hello world'

    pwa_settings.offline_retry_button = False

    pwa_settings.save()

    pwa_settings.application_icon = File(BytesIO(b'te\30st'), 'test.png')

    pwa_settings.save()

    import_site(data={}, clean=True)

    assert PwaSettings.objects.all().count() == 0

    import_site(data=json.loads(output))

    assert PwaSettings.singleton().offline_retry_button is False

    assert PwaSettings.singleton().offline_text == 'Hello world'

    # check identical file was not touched

    assert os.path.basename(PwaSettings.objects.get().application_icon.file.name) == 'test.png'

    # check with a change in icon file name

    data = json.loads(output)

    data['pwa']['settings']['icon:base64'] = force_text(base64.encodebytes(b'TEST2'))

    data['pwa']['settings']['application_icon'] = 'pwa/test2.png'

    import_site(data=data)

    assert os.path.basename(PwaSettings.objects.get().application_icon.file.name) == 'test2.png'

    assert PwaSettings.objects.get().application_icon.read() == b'TEST2'

def test_import_export_pwa_navigation(app, some_data):

    page = Page.objects.get(slug='one')

    entry1 = PwaNavigationEntry(label='a', url='/', order=0)

    entry2 = PwaNavigationEntry(link_page=page, order=1, icon=File(BytesIO(b'te\30st'), 'test.png'))

    entry1.save()

    entry2.save()

    import_site(data={}, clean=True)

    assert PwaNavigationEntry.objects.all().count() == 0

    import_site(data=json.loads(output))

    assert PwaNavigationEntry.objects.all().count() == 2

    # check identical file was not touched

    assert os.path.basename(PwaNavigationEntry.objects.get(order=1).icon.file.name) == 'test.png'

    assert PwaNavigationEntry.objects.get(order=1).icon.read() == b'te\30st'

    data = json.loads(output)

    data['pwa']['navigation'][1]['fields']['icon'] = 'pwa/test2.png'

    data['pwa']['navigation'][1]['icon:base64'] = force_text(base64.encodebytes(b'TEST2'))

    import_site(data=data)

    assert PwaNavigationEntry.objects.all().count() == 2

    assert os.path.basename(PwaNavigationEntry.objects.get(order=1).icon.file.name) == 'test2.png'

    assert PwaNavigationEntry.objects.get(order=1).icon.read() == b'TEST2'

def test_import_export_gallery_images(app, some_data):

    page = Page.objects.get(slug='one')

    gallery = GalleryCell(page=page, order=2, placeholder='images')

    gallery.save()

    image1 = Image(gallery=gallery, image='path/foo.jpg', title='foo', order=1)

    image2 = Image(gallery=gallery, image='path/bar.jpg', title='bar', order=2)

    image1.save()

    image2.save()

    import_site(data={}, clean=True)

    assert Image.objects.all().count() == 0

    import_site(data=json.loads(output))

    assert Image.objects.all().count() == 2

    image1 = Image.objects.get(title='foo')

    assert image1.image == 'path/foo.jpg'

    assert image1.gallery.placeholder == 'images'

def test_import_export_extra_fields(app, some_data):

    site_export = export_site()

    for page in site_export['pages']:

        if page['fields']['slug'] == 'one':

            page['fields']['extra_field_not_in_model'] = True

        elif page['fields']['slug'] == 'three':

            page['cells'][0]['fields']['extra_field_not_in_model'] = True

        call_command('import_site', filename)

def test_import_export_payment(app):

    backend = PaymentBackend.objects.create(label='Test', slug='test', service_options={'test': True})

    Regie.objects.create(label='Test regie', slug='test-regie', payment_backend=backend)

    Regie.objects.create(label='Test regie 2', slug='test-regie-2', payment_backend=backend)

    payload = json.loads(output)

    assert len(payload['payment']['backends']) == 1

    assert len(payload['payment']['regies']) == 2

    import_site(payload)

    assert PaymentBackend.objects.count() == 1

    assert Regie.objects.count() == 2

    assert Regie.objects.count() == 2

    regie = Regie.objects.first()

    assert regie.payment_backend == backend

    import_site(data={}, clean=True)

    assert PaymentBackend.objects.count() == 0

    assert Regie.objects.count() == 0

    assert len(json.loads(empty_output)['payment']['backends']) == 0

    assert len(json.loads(empty_output)['payment']['regies']) == 0