devicehub-teal/tests/test_action.py

import copy
import ipaddress
import json
import os
import shutil
from datetime import datetime, timedelta
from decimal import Decimal
from io import BytesIO
from json.decoder import JSONDecodeError
from typing import Tuple, Type

import pytest
from dateutil.tz import tzutc
from flask import current_app as app
from flask import g
from pytest import raises
from sqlalchemy.util import OrderedSet
from teal.enums import Currency, Subdivision

from ereuse_devicehub.client import Client, UserClient
from ereuse_devicehub.db import db
from ereuse_devicehub.devicehub import Devicehub
from ereuse_devicehub.resources import enums
from ereuse_devicehub.resources.action import models
from ereuse_devicehub.resources.agent.models import Person
from ereuse_devicehub.resources.device import states
from ereuse_devicehub.resources.device.models import (
    Desktop,
    Device,
    GraphicCard,
    HardDrive,
    RamModule,
    SolidStateDrive,
)
from ereuse_devicehub.resources.enums import (
    ComputerChassis,
    Severity,
    TestDataStorageLength,
)
from ereuse_devicehub.resources.lot.models import Lot
from ereuse_devicehub.resources.tradedocument.models import TradeDocument
from ereuse_devicehub.resources.user.models import User
from tests import conftest
from tests.conftest import create_user, file, json_encode, yaml2json


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_author():
    """Checks the default created author.

    Note that the author can be accessed after inserting the row.
    """
    user = create_user()
    g.user = user
    e = models.ActionWithOneDevice(device=Device())
    db.session.add(e)
    assert e.author is None
    assert e.author_id is None
    db.session.commit()
    assert e.author == user


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.auth_app_context.__name__)
def test_erase_basic():
    erasure = models.EraseBasic(
        device=HardDrive(serial_number='foo', manufacturer='bar', model='foo-bar'),
        steps=[models.StepZero(**conftest.T), models.StepRandom(**conftest.T)],
        **conftest.T,
    )
    db.session.add(erasure)
    db.session.commit()
    db_erasure = models.EraseBasic.query.one()
    assert erasure == db_erasure
    assert next(iter(db_erasure.device.actions)) == erasure
    assert not erasure.standards, 'EraseBasic themselves do not have standards'


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.auth_app_context.__name__)
def test_validate_device_data_storage():
    """Checks the validation for data-storage-only actions works."""
    # We can't set a GraphicCard
    with pytest.raises(
        TypeError,
        message='EraseBasic.device must be a DataStorage '
        'but you passed <GraphicCard None model=\'foo-bar\' S/N=\'foo\'>',
    ):
        models.EraseBasic(
            device=GraphicCard(
                serial_number='foo', manufacturer='bar', model='foo-bar'
            ),
            clean_with_zeros=True,
            **conftest.T,
        )


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.auth_app_context.__name__)
def test_erase_sectors_steps_erasure_standards_hmg_is5():
    erasure = models.EraseSectors(
        device=SolidStateDrive(
            serial_number='foo', manufacturer='bar', model='foo-bar'
        ),
        steps=[
            models.StepZero(**conftest.T),
            models.StepRandom(**conftest.T),
            models.StepRandom(**conftest.T),
        ],
        **conftest.T,
    )
    db.session.add(erasure)
    db.session.commit()
    db_erasure = models.EraseSectors.query.one()
    # Steps are in order
    assert db_erasure.steps[0].num == 0
    assert db_erasure.steps[1].num == 1
    assert db_erasure.steps[2].num == 2
    assert {enums.ErasureStandards.HMG_IS5} == erasure.standards


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.auth_app_context.__name__)
def test_test_data_storage_working():
    """Tests TestDataStorage with the resulting properties in Device."""
    hdd = HardDrive(serial_number='foo', manufacturer='bar', model='foo-bar')
    test = models.TestDataStorage(
        device=hdd,
        severity=Severity.Error,
        elapsed=timedelta(minutes=25),
        length=TestDataStorageLength.Short,
        status=':-(',
        lifetime=timedelta(days=120),
    )
    db.session.add(test)
    db.session.flush()
    assert hdd.working == [test]
    assert not hdd.problems
    # Add new test overriding the first test in the problems
    # / working condition
    test2 = models.TestDataStorage(
        device=hdd,
        severity=Severity.Warning,
        elapsed=timedelta(minutes=25),
        length=TestDataStorageLength.Short,
        status=':-(',
        lifetime=timedelta(days=120),
    )
    db.session.add(test2)
    db.session.flush()
    assert hdd.working == [test2]
    assert hdd.problems == []


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.auth_app_context.__name__)
def test_install():
    hdd = HardDrive(serial_number='sn')
    install = models.Install(
        name='LinuxMint 18.04 es', elapsed=timedelta(seconds=25), device=hdd
    )
    db.session.add(install)
    db.session.commit()


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.auth_app_context.__name__)
def test_update_components_action_one():
    computer = Desktop(
        serial_number='sn1',
        model='ml1',
        manufacturer='mr1',
        chassis=ComputerChassis.Tower,
    )
    hdd = HardDrive(serial_number='foo', manufacturer='bar', model='foo-bar')
    computer.components.add(hdd)

    # Add action
    test = models.StressTest(elapsed=timedelta(minutes=1))
    computer.actions_one.add(test)
    assert test.device == computer
    assert next(iter(test.components)) == hdd, 'Action has to have new components'

    # Remove action
    computer.actions_one.clear()
    assert not test.device
    assert not test.components, 'Action has to loose the components'

    # If we add a component to a device AFTER assigning the action
    # to the device, the action doesn't get the new component
    computer.actions_one.add(test)
    ram = RamModule()
    computer.components.add(ram)
    assert len(test.components) == 1


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.auth_app_context.__name__)
def test_update_components_action_multiple():
    computer = Desktop(
        serial_number='sn1',
        model='ml1',
        manufacturer='mr1',
        chassis=ComputerChassis.Tower,
    )
    hdd = HardDrive(serial_number='foo', manufacturer='bar', model='foo-bar')
    computer.components.add(hdd)

    ready = models.Ready()
    assert not ready.devices
    assert not ready.components

    # Add
    computer.actions_multiple.add(ready)
    assert ready.devices == OrderedSet([computer])
    assert next(iter(ready.components)) == hdd

    # Remove
    computer.actions_multiple.remove(ready)
    assert not ready.devices
    assert not ready.components

    # init / replace collection
    ready.devices = OrderedSet([computer])
    assert ready.devices
    assert ready.components


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.auth_app_context.__name__)
def test_update_parent():
    computer = Desktop(
        serial_number='sn1',
        model='ml1',
        manufacturer='mr1',
        chassis=ComputerChassis.Tower,
    )
    hdd = HardDrive(serial_number='foo', manufacturer='bar', model='foo-bar')
    computer.components.add(hdd)

    # Add
    benchmark = models.BenchmarkDataStorage()
    benchmark.device = hdd
    assert benchmark.parent == computer
    assert not benchmark.components

    # Remove
    benchmark.device = None
    assert not benchmark.parent


@pytest.mark.mvp
@pytest.mark.parametrize(
    'action_model_state',
    (
        pytest.param(ams, id=ams[0].__class__.__name__)
        for ams in [
            (models.ToPrepare, states.Physical.ToPrepare),
            (models.Prepare, states.Physical.Prepare),
            (models.ToRepair, states.Physical.ToRepair),
            (models.Ready, states.Physical.Ready),
        ]
    ),
)
def test_generic_action(
    action_model_state: Tuple[models.Action, states.Trading], user: UserClient
):
    """Tests POSTing all generic actions."""
    action_model, state = action_model_state
    snapshot, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    action = {'type': action_model.t, 'devices': [snapshot['device']['id']]}
    action, _ = user.post(action, res=models.Action)
    assert action['devices'][0]['id'] == snapshot['device']['id']
    device, _ = user.get(res=Device, item=snapshot['device']['devicehubID'])
    assert device['actions'][-1]['id'] == action['id']
    assert device['physical'] == state.name
    # Check if the update of device is changed
    assert snapshot['device']['updated'] != device['updated']


@pytest.mark.mvp
@pytest.mark.parametrize(
    'action_model',
    (
        pytest.param(ams, id=ams.__class__.__name__)
        for ams in [models.Recycling, models.Use, models.Refurbish, models.Management]
    ),
)
def test_simple_status_actions(
    action_model: models.Action, user: UserClient, user2: UserClient
):
    """Simple test of status action."""
    snap, _ = user.post(file('basic.snapshot'), res=models.Snapshot)

    action = {'type': action_model.t, 'devices': [snap['device']['id']]}
    action, _ = user.post(action, res=models.Action)
    device, _ = user.get(res=Device, item=snap['device']['devicehubID'])
    assert device['actions'][-1]['id'] == action['id']
    assert action['author']['id'] == user.user['id']
    assert action['rol_user']['id'] == user.user['id']


@pytest.mark.mvp
@pytest.mark.parametrize(
    'action_model',
    (
        pytest.param(ams, id=ams.__class__.__name__)
        for ams in [models.Recycling, models.Use, models.Refurbish, models.Management]
    ),
)
def test_outgoinlot_status_actions(
    action_model: models.Action, user: UserClient, user2: UserClient
):
    """Test of status actions in outgoinlot."""
    snap, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    device, _ = user.get(res=Device, item=snap['device']['devicehubID'])
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=[('id', device['id'])]
    )

    request_post = {
        'type': 'Trade',
        'devices': [device['id']],
        'userFromEmail': user.email,
        'userToEmail': user2.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    action = {'type': action_model.t, 'devices': [device['id']]}
    action, _ = user.post(action, res=models.Action)
    device, _ = user.get(res=Device, item=snap['device']['devicehubID'])

    assert device['actions'][-1]['id'] == action['id']
    assert action['author']['id'] == user.user['id']
    assert action['rol_user']['id'] == user2.user['id']

    # Remove device from lot
    lot, _ = user.delete(
        {},
        res=Lot,
        item='{}/devices'.format(lot['id']),
        query=[('id', device['id'])],
        status=200,
    )

    action = {'type': action_model.t, 'devices': [device['id']]}
    action, _ = user.post(action, res=models.Action)
    device, _ = user.get(res=Device, item=snap['device']['devicehubID'])

    assert device['actions'][-1]['id'] == action['id']
    assert action['author']['id'] == user.user['id']
    assert action['rol_user']['id'] == user2.user['id']


@pytest.mark.mvp
@pytest.mark.parametrize(
    'action_model',
    (
        pytest.param(ams, id=ams.__class__.__name__)
        for ams in [models.Recycling, models.Use, models.Refurbish, models.Management]
    ),
)
def test_incominglot_status_actions(
    action_model: models.Action, user: UserClient, user2: UserClient
):
    """Test of status actions in outgoinlot."""
    snap, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    device, _ = user.get(res=Device, item=snap['device']['devicehubID'])
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=[('id', device['id'])]
    )

    request_post = {
        'type': 'Trade',
        'devices': [device['id']],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    action = {'type': action_model.t, 'devices': [device['id']]}
    action, _ = user.post(action, res=models.Action)
    device, _ = user.get(res=Device, item=snap['device']['devicehubID'])

    assert device['actions'][-1]['id'] == action['id']
    assert action['author']['id'] == user.user['id']
    assert action['rol_user']['id'] == user.user['id']


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_history_status_actions(user: UserClient, user2: UserClient):
    """Test for check the status actions."""
    snap, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    device = Device.query.filter_by(id=snap['device']['id']).one()

    # Case 1
    action = {'type': models.Recycling.t, 'devices': [device.id]}
    action, _ = user.post(action, res=models.Action)

    assert str(device.actions[-1].id) == action['id']
    assert action['id'] == str(device.status.id)
    assert device.status.t == models.Recycling.t
    assert [action['id']] == [str(ac.id) for ac in device.history_status]

    # Case 2
    action2 = {'type': models.Refurbish.t, 'devices': [device.id]}
    action2, _ = user.post(action2, res=models.Action)
    assert action2['id'] == str(device.status.id)
    assert device.status.t == models.Refurbish.t
    assert [action2['id']] == [str(ac.id) for ac in device.history_status]

    # Case 3
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=[('id', device.id)]
    )

    request_post = {
        'type': 'Trade',
        'devices': [device.id],
        'userFromEmail': user.email,
        'userToEmail': user2.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    action3 = {'type': models.Use.t, 'devices': [device.id]}
    action3, _ = user.post(action3, res=models.Action)
    assert action3['id'] == str(device.status.id)
    assert device.status.t == models.Use.t
    assert [action2['id'], action3['id']] == [
        str(ac.id) for ac in device.history_status
    ]


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_use_changing_owner(user: UserClient, user2: UserClient):
    """Check if is it possible to do a use action for one device
    when you are not the owner.
    """
    snap, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    device = Device.query.filter_by(id=snap['device']['id']).one()

    assert device.owner.email == user.email

    # Trade
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=[('id', device.id)]
    )

    request_post = {
        'type': 'Trade',
        'devices': [device.id],
        'userFromEmail': user.email,
        'userToEmail': user2.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()

    # Doble confirmation and change of owner
    request_confirm = {'type': 'Confirm', 'action': trade.id, 'devices': [device.id]}

    user2.post(res=models.Action, data=request_confirm)
    assert device.owner.email == user2.email

    # Adding action Use
    action3 = {'type': models.Use.t, 'devices': [device.id]}
    action3, _ = user.post(action3, res=models.Action)
    assert action3['id'] == str(device.status.id)
    assert device.status.t == models.Use.t
    assert device.owner.email == user2.email


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_recycling_container(user: UserClient):
    """Test of status action recycling for a container."""
    lot, _ = user.post({'name': 'MyLotOut'}, res=Lot)
    url = ('http://www.ereuse.org/',)
    request_post = {
        'filename': 'test.pdf',
        'hash': 'bbbbbbbb',
        'url': url,
        'weight': 150,
        'lot': lot['id'],
    }
    tradedocument, _ = user.post(res=TradeDocument, data=request_post)
    action = {
        'type': models.Recycling.t,
        'devices': [],
        'documents': [tradedocument['id']],
    }
    action, _ = user.post(action, res=models.Action)
    trade = TradeDocument.query.one()
    assert str(trade.actions[0].id) == action['id']


@pytest.mark.mvp
@pytest.mark.parametrize(
    'action_model',
    (
        pytest.param(ams, id=ams.__class__.__name__)
        for ams in [models.Recycling, models.Use, models.Refurbish, models.Management]
    ),
)
def test_status_without_lot(action_model: models.Action, user: UserClient):
    """Test of status actions for devices without lot."""
    snap, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    action = {'type': action_model.t, 'devices': [snap['device']['id']]}
    action, _ = user.post(action, res=models.Action)
    device, _ = user.get(res=Device, item=snap['device']['devicehubID'])
    assert device['actions'][-1]['id'] == action['id']


@pytest.mark.mvp
@pytest.mark.parametrize(
    'action_model',
    (
        pytest.param(ams, id=ams.__class__.__name__)
        for ams in [models.Recycling, models.Use, models.Refurbish, models.Management]
    ),
)
def test_status_in_temporary_lot(action_model: models.Action, user: UserClient):
    """Test of status actions for devices in a temporary lot."""
    snap, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    device_id = snap['device']['id']
    lot, _ = user.post({'name': 'MyLotOut'}, res=Lot)
    lot, _ = user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=[('id', device_id)]
    )
    action = {'type': action_model.t, 'devices': [device_id]}
    action, _ = user.post(action, res=models.Action)
    device, _ = user.get(res=Device, item=snap['device']['devicehubID'])
    assert device['actions'][-1]['id'] == action['id']


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_live(user: UserClient, client: Client, app: Devicehub):
    """Tests inserting a Live into the database and GETting it."""
    acer = file('acer.happy.battery.snapshot')
    snapshot, _ = user.post(acer, res=models.Snapshot)
    acer = yaml2json('acer.happy.battery.snapshot')
    device_id = snapshot['device']['id']
    post_request = {
        "transaction": "ccc",
        "name": "John",
        "endUsers": 1,
        "devices": [device_id],
        "description": "aaa",
        "finalUserCode": "abcdefjhi",
        "startTime": "2020-11-01T02:00:00+00:00",
        "endTime": "2020-12-01T02:00:00+00:00",
    }

    user.post(res=models.Allocate, data=post_request)
    hdd = [c for c in acer['components'] if c['type'] == 'HardDrive'][0]
    hdd_action = [a for a in hdd['actions'] if a['type'] == 'TestDataStorage'][0]
    hdd_action['lifetime'] += 1000
    acer.pop('elapsed')
    acer['licence_version'] = '1.0.0'
    snapshot, _ = client.post(acer, res=models.Live)
    db_device = Device.query.filter_by(id=device_id).one()
    action_live = [a for a in db_device.actions if a.type == 'Live']
    assert len(action_live) == 1
    assert action_live[0].usage_time_hdd == timedelta(hours=hdd_action['lifetime'])
    assert action_live[0].usage_time_allocate == timedelta(hours=1000)
    assert action_live[0].final_user_code == post_request['finalUserCode']
    assert action_live[0].serial_number == 'wd-wx11a80w7430'
    assert action_live[0].licence_version == '1.0'
    assert str(action_live[0].snapshot_uuid) == acer['uuid']
    tmp_snapshots = app.config['TMP_LIVES']
    shutil.rmtree(tmp_snapshots)


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_live_example(user: UserClient, client: Client, app: Devicehub):
    """Tests inserting a Live into the database and GETting it."""
    acer = file('snapshotLive')
    snapshot, _ = user.post(acer, res=models.Snapshot)
    device_id = snapshot['device']['id']
    post_request = {
        "transaction": "ccc",
        "name": "John",
        "endUsers": 1,
        "devices": [device_id],
        "description": "aaa",
        "finalUserCode": "abcdefjhi",
        "startTime": "2020-11-01T02:00:00+00:00",
        "endTime": "2020-12-01T02:00:00+00:00",
    }

    user.post(res=models.Allocate, data=post_request)

    acer = yaml2json('live')
    live, _ = client.post(acer, res=models.Live)
    db_device = Device.query.filter_by(id=device_id).one()
    action_live = [a for a in db_device.actions if a.type == 'Live']
    assert len(action_live) == 1
    assert str(action_live[0].snapshot_uuid) == acer['uuid']
    tmp_snapshots = app.config['TMP_LIVES']
    shutil.rmtree(tmp_snapshots)


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_live_two_users(
    user: UserClient, user2: UserClient, client: Client, app: Devicehub
):
    """Tests inserting a Live into the database and GETting it."""
    acer = file('snapshotLive')
    snapshot, _ = user.post(acer, res=models.Snapshot)
    acer2 = yaml2json('snapshotLive')
    acer2['uuid'] = '3b6a9288-0ba6-4bdd-862a-2b1f660e7115'
    snapshot2, _ = user2.post(json_encode(acer2), res=models.Snapshot)
    device_id = snapshot['device']['id']
    post_request = {
        "transaction": "ccc",
        "name": "John",
        "endUsers": 1,
        "devices": [device_id],
        "description": "aaa",
        "finalUserCode": "abcdefjhi",
        "startTime": "2020-11-01T02:00:00+00:00",
        "endTime": "2020-12-01T02:00:00+00:00",
    }

    user.post(res=models.Allocate, data=post_request)

    acer = yaml2json('live')
    live, _ = client.post(acer, res=models.Live)
    db_device = Device.query.filter_by(id=device_id).one()
    action_live = [a for a in db_device.actions if a.type == 'Live']
    assert len(action_live) == 1
    assert str(action_live[0].snapshot_uuid) == acer['uuid']
    tmp_snapshots = app.config['TMP_LIVES']
    shutil.rmtree(tmp_snapshots)


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_live_two_allocated(
    user: UserClient, user2: UserClient, client: Client, app: Devicehub
):
    """Tests inserting a Live into the database and GETting it."""
    acer = file('snapshotLive')
    snapshot, _ = user.post(acer, res=models.Snapshot)
    acer2 = yaml2json('snapshotLive')
    acer2['uuid'] = '3b6a9288-0ba6-4bdd-862a-2b1f660e7115'
    snapshot2, _ = user2.post(json_encode(acer2), res=models.Snapshot)
    device_id = snapshot['device']['id']
    device_id2 = snapshot2['device']['id']
    post_request = {
        "transaction": "ccc",
        "name": "John",
        "endUsers": 1,
        "devices": [device_id],
        "description": "aaa",
        "finalUserCode": "abcdefjhi",
        "startTime": "2020-11-01T02:00:00+00:00",
        "endTime": "2020-12-01T02:00:00+00:00",
    }
    post_request2 = {
        "transaction": "ccc",
        "name": "John",
        "endUsers": 1,
        "devices": [device_id2],
        "description": "aaa",
        "finalUserCode": "abcdefjhi",
        "startTime": "2020-11-01T02:00:00+00:00",
        "endTime": "2020-12-01T02:00:00+00:00",
    }

    user.post(res=models.Allocate, data=post_request)
    user2.post(res=models.Allocate, data=post_request2)

    acer = yaml2json('live')
    live, _ = client.post(acer, res=models.Live, status=422)
    message = 'Expected only one Device but multiple where found'
    assert live['message'] == message
    tmp_snapshots = app.config['TMP_LIVES']
    shutil.rmtree(tmp_snapshots)


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_live_without_TestDataStorage(user: UserClient, client: Client, app: Devicehub):
    """Tests inserting a Live into the database and GETting it.
    If the live don't have a TestDataStorage, then save live and response None
    """
    acer = file('acer.happy.battery.snapshot')
    snapshot, _ = user.post(acer, res=models.Snapshot)
    device_id = snapshot['device']['id']
    db_device = Device.query.filter_by(id=device_id).one()
    post_request = {
        "transaction": "ccc",
        "name": "John",
        "endUsers": 1,
        "devices": [device_id],
        "description": "aaa",
        "finalUserCode": "abcdefjhi",
        "startTime": "2020-11-01T02:00:00+00:00",
        "endTime": "2020-12-01T02:00:00+00:00",
    }

    user.post(res=models.Allocate, data=post_request)
    acer = yaml2json('acer.happy.battery.snapshot')
    acer['uuid'] = "490fb8c0-81a1-42e9-95e0-5e7db7038ec3"
    actions = [
        a for a in acer['components'][7]['actions'] if a['type'] != 'TestDataStorage'
    ]
    acer['components'][7]['actions'] = actions
    acer.pop('elapsed')
    acer['licence_version'] = '1.0.0'
    live, _ = client.post(acer, res=models.Live)
    assert live['severity'] == 'Warning'
    description = "We don't found any TestDataStorage for disk sn: wd-wx11a80w7430"
    assert live['description'] == description
    db_live = models.Live.query.filter_by(id=live['id']).one()
    assert db_live.usage_time_hdd is None
    tmp_snapshots = app.config['TMP_LIVES']
    shutil.rmtree(tmp_snapshots)


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_live_without_hdd_1(user: UserClient, client: Client, app: Devicehub):
    """Tests inserting a Live into the database and GETting it.
    The snapshot have hdd but the live no, and response 404
    """
    acer = file('acer.happy.battery.snapshot')
    snapshot, _ = user.post(acer, res=models.Snapshot)
    device_id = snapshot['device']['id']
    db_device = Device.query.filter_by(id=device_id).one()
    post_request = {
        "transaction": "ccc",
        "name": "John",
        "endUsers": 1,
        "devices": [device_id],
        "description": "aaa",
        "finalUserCode": "abcdefjhi",
        "startTime": "2020-11-01T02:00:00+00:00",
        "endTime": "2020-12-01T02:00:00+00:00",
    }

    user.post(res=models.Allocate, data=post_request)
    acer = yaml2json('acer.happy.battery.snapshot')
    acer['uuid'] = "490fb8c0-81a1-42e9-95e0-5e7db7038ec3"
    components = [a for a in acer['components'] if a['type'] != 'HardDrive']
    acer['components'] = components
    acer.pop('elapsed')
    acer['licence_version'] = '1.0.0'
    response, _ = client.post(acer, res=models.Live, status=404)
    assert "The There aren't any disk in this device" in response['message']
    tmp_snapshots = app.config['TMP_LIVES']
    shutil.rmtree(tmp_snapshots)


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_live_without_hdd_2(user: UserClient, client: Client, app: Devicehub):
    """Tests inserting a Live into the database and GETting it.
    The snapshot haven't hdd and the live neither, and response 404
    """
    acer = yaml2json('acer.happy.battery.snapshot')
    components = [a for a in acer['components'] if a['type'] != 'HardDrive']
    acer['components'] = components
    snapshot, _ = user.post(json_encode(acer), res=models.Snapshot)
    device_id = snapshot['device']['id']
    db_device = Device.query.filter_by(id=device_id).one()
    post_request = {
        "transaction": "ccc",
        "name": "John",
        "endUsers": 1,
        "devices": [device_id],
        "description": "aaa",
        "finalUserCode": "abcdefjhi",
        "startTime": "2020-11-01T02:00:00+00:00",
        "endTime": "2020-12-01T02:00:00+00:00",
    }

    user.post(res=models.Allocate, data=post_request)
    acer['uuid'] = "490fb8c0-81a1-42e9-95e0-5e7db7038ec3"
    acer.pop('elapsed')
    acer['licence_version'] = '1.0.0'
    response, _ = client.post(acer, res=models.Live, status=404)
    assert "The There aren't any disk in this device" in response['message']
    tmp_snapshots = app.config['TMP_LIVES']
    shutil.rmtree(tmp_snapshots)


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_live_without_hdd_3(user: UserClient, client: Client, app: Devicehub):
    """Tests inserting a Live into the database and GETting it.
    The snapshot haven't hdd and the live have, and save the live
    with usage_time_allocate == 0
    """
    acer = yaml2json('acer.happy.battery.snapshot')
    acer['uuid'] = "490fb8c0-81a1-42e9-95e0-5e7db7038ec3"
    components = [a for a in acer['components'] if a['type'] != 'HardDrive']
    acer['components'] = components
    snapshot, _ = user.post(json_encode(acer), res=models.Snapshot)
    device_id = snapshot['device']['id']
    db_device = Device.query.filter_by(id=device_id).one()
    post_request = {
        "transaction": "ccc",
        "name": "John",
        "endUsers": 1,
        "devices": [device_id],
        "description": "aaa",
        "finalUserCode": "abcdefjhi",
        "startTime": "2020-11-01T02:00:00+00:00",
        "endTime": "2020-12-01T02:00:00+00:00",
    }

    user.post(res=models.Allocate, data=post_request)
    acer = yaml2json('acer.happy.battery.snapshot')
    acer.pop('elapsed')
    acer['licence_version'] = '1.0.0'
    live, _ = client.post(acer, res=models.Live)
    assert live['severity'] == 'Warning'
    description = "Don't exist one previous live or snapshot as reference"
    assert live['description'] == description
    db_live = models.Live.query.filter_by(id=live['id']).one()
    assert str(db_live.usage_time_hdd) == '195 days, 12:00:00'
    assert str(db_live.usage_time_allocate) == '0:00:00'
    tmp_snapshots = app.config['TMP_LIVES']
    shutil.rmtree(tmp_snapshots)


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_live_with_hdd_with_old_time(user: UserClient, client: Client, app: Devicehub):
    """Tests inserting a Live into the database and GETting it.
    The snapshot hdd have a lifetime higher than lifetime of the live action
    save the live with usage_time_allocate == 0
    """
    acer = file('acer.happy.battery.snapshot')
    snapshot, _ = user.post(acer, res=models.Snapshot)
    device_id = snapshot['device']['id']
    db_device = Device.query.filter_by(id=device_id).one()
    post_request = {
        "transaction": "ccc",
        "name": "John",
        "endUsers": 1,
        "devices": [device_id],
        "description": "aaa",
        "finalUserCode": "abcdefjhi",
        "startTime": "2020-11-01T02:00:00+00:00",
        "endTime": "2020-12-01T02:00:00+00:00",
    }

    user.post(res=models.Allocate, data=post_request)
    acer = yaml2json('acer.happy.battery.snapshot')
    acer['uuid'] = "490fb8c0-81a1-42e9-95e0-5e7db7038ec3"
    action = [
        a for a in acer['components'][7]['actions'] if a['type'] == 'TestDataStorage'
    ]
    action[0]['lifetime'] -= 100
    acer.pop('elapsed')
    acer['licence_version'] = '1.0.0'
    live, _ = client.post(acer, res=models.Live)
    assert live['severity'] == 'Warning'
    description = "The difference with the last live/snapshot is negative"
    assert live['description'] == description
    db_live = models.Live.query.filter_by(id=live['id']).one()
    assert str(db_live.usage_time_hdd) == '191 days, 8:00:00'
    assert str(db_live.usage_time_allocate) == '0:00:00'
    tmp_snapshots = app.config['TMP_LIVES']
    shutil.rmtree(tmp_snapshots)


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_live_search_last_allocate(user: UserClient, client: Client, app: Devicehub):
    """Tests inserting a Live into the database and GETting it."""
    acer = file('acer.happy.battery.snapshot')
    snapshot, _ = user.post(acer, res=models.Snapshot)
    device_id = snapshot['device']['id']
    post_request = {
        "transaction": "ccc",
        "name": "John",
        "endUsers": 1,
        "devices": [device_id],
        "description": "aaa",
        "finalUserCode": "abcdefjhi",
        "startTime": "2020-11-01T02:00:00+00:00",
        "endTime": "2020-12-01T02:00:00+00:00",
    }

    user.post(res=models.Allocate, data=post_request)
    acer = yaml2json('acer.happy.battery.snapshot')
    acer['uuid'] = "490fb8c0-81a1-42e9-95e0-5e7db7038ec3"
    hdd = [c for c in acer['components'] if c['type'] == 'HardDrive'][0]
    hdd_action = [a for a in hdd['actions'] if a['type'] == 'TestDataStorage'][0]
    hdd_action['lifetime'] += 1000
    acer.pop('elapsed')
    acer['licence_version'] = '1.0.0'
    live, _ = client.post(acer, res=models.Live)
    acer['uuid'] = "490fb8c0-81a1-42e9-95e0-5e7db7038ec4"
    actions = [
        a for a in acer['components'][7]['actions'] if a['type'] != 'TestDataStorage'
    ]
    acer['components'][7]['actions'] = actions
    live, _ = client.post(acer, res=models.Live)
    assert live['usageTimeAllocate'] == 1000
    tmp_snapshots = app.config['TMP_LIVES']
    shutil.rmtree(tmp_snapshots)


@pytest.mark.mvp
def test_save_live_json(app: Devicehub, user: UserClient, client: Client):
    """This test check if works the function save_snapshot_in_file"""
    acer = yaml2json('acer.happy.battery.snapshot')
    snapshot, _ = user.post(json_encode(acer), res=models.Snapshot)
    debug = 'AAA'
    acer['debug'] = debug
    device_id = snapshot['device']['id']
    post_request = {
        "transaction": "ccc",
        "name": "John",
        "endUsers": 1,
        "devices": [device_id],
        "description": "aaa",
        "finalUserCode": "abcdefjhi",
        "startTime": "2020-11-01T02:00:00+00:00",
        "endTime": "2020-12-01T02:00:00+00:00",
    }

    user.post(res=models.Allocate, data=post_request)
    acer['uuid'] = "490fb8c0-81a1-42e9-95e0-5e7db7038ec3"
    hdd = [c for c in acer['components'] if c['type'] == 'HardDrive'][0]
    hdd_action = [a for a in hdd['actions'] if a['type'] == 'TestDataStorage'][0]
    hdd_action['lifetime'] += 1000
    acer.pop('elapsed')
    acer['licence_version'] = '1.0.0'
    live, _ = client.post(acer, res=models.Live)

    tmp_snapshots = app.config['TMP_LIVES']
    path_dir_base = os.path.join(tmp_snapshots)

    uuid = acer['uuid']
    files = [x for x in os.listdir(path_dir_base) if uuid in x]

    snapshot = {'debug': ''}
    if files:
        path_snapshot = os.path.join(path_dir_base, files[-1])
        with open(path_snapshot) as file_snapshot:
            snapshot = json.loads(file_snapshot.read())

    shutil.rmtree(tmp_snapshots)

    assert snapshot['debug'] == debug


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_licences(client: Client):
    """Tests inserting a Live into the database and GETting it."""
    licences, _ = client.get('/licences/')
    licences = json.loads(licences)
    assert licences[0]['USOdyPrivacyPolicyVersion'] == '1.0.0'


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_allocate(user: UserClient):
    """Tests allocate"""
    snapshot, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    device_id = snapshot['device']['id']
    devicehub_id = snapshot['device']['devicehubID']
    post_request = {
        "transaction": "ccc",
        "finalUserCode": "aabbcc",
        "name": "John",
        "severity": "Info",
        "endUsers": 1,
        "devices": [device_id],
        "description": "aaa",
        "startTime": "2020-11-01T02:00:00+00:00",
        "endTime": "2020-12-01T02:00:00+00:00",
    }

    allocate, _ = user.post(res=models.Allocate, data=post_request)
    # Normal allocate
    device, _ = user.get(res=Device, item=devicehub_id)
    assert device['allocated'] == True
    action = [a for a in device['actions'] if a['type'] == 'Allocate'][0]
    assert action['transaction'] == allocate['transaction']
    assert action['finalUserCode'] == allocate['finalUserCode']
    assert action['created'] == allocate['created']
    assert action['startTime'] == allocate['startTime']
    assert action['endUsers'] == allocate['endUsers']
    assert action['name'] == allocate['name']

    post_bad_request1 = copy.copy(post_request)
    post_bad_request1['endUsers'] = 2
    post_bad_request2 = copy.copy(post_request)
    post_bad_request2['startTime'] = "2020-11-01T02:00:00+00:01"
    post_bad_request3 = copy.copy(post_request)
    post_bad_request3['transaction'] = "aaa"
    res1, _ = user.post(res=models.Allocate, data=post_bad_request1, status=422)
    res2, _ = user.post(res=models.Allocate, data=post_bad_request2, status=422)
    res3, _ = user.post(res=models.Allocate, data=post_bad_request3, status=422)
    for r in (res1, res2, res3):
        assert r['code'] == 422
        assert r['type'] == 'ValidationError'


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_allocate_bad_dates(user: UserClient):
    """Tests allocate"""
    snapshot, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    device_id = snapshot['device']['id']
    delay = timedelta(days=30)
    future = datetime.now().replace(tzinfo=tzutc()) + delay
    post_request = {
        "transaction": "ccc",
        "finalUserCode": "aabbcc",
        "name": "John",
        "severity": "Info",
        "end_users": 1,
        "devices": [device_id],
        "description": "aaa",
        "start_time": future,
    }

    res, _ = user.post(res=models.Allocate, data=post_request, status=422)
    assert res['code'] == 422
    assert res['type'] == 'ValidationError'


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_deallocate(user: UserClient):
    """Tests deallocate"""
    snapshot, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    device_id = snapshot['device']['id']
    devicehub_id = snapshot['device']['devicehubID']
    post_deallocate = {
        "startTime": "2020-11-01T02:00:00+00:00",
        "transaction": "ccc",
        "devices": [device_id],
    }
    res, _ = user.post(res=models.Deallocate, data=post_deallocate, status=422)
    assert res['code'] == 422
    assert res['type'] == 'ValidationError'
    post_allocate = {
        "transaction": "ccc",
        "name": "John",
        "endUsers": 1,
        "devices": [device_id],
        "description": "aaa",
        "startTime": "2020-11-01T02:00:00+00:00",
        "endTime": "2020-12-01T02:00:00+00:00",
    }

    user.post(res=models.Allocate, data=post_allocate)
    device, _ = user.get(res=Device, item=devicehub_id)
    assert device['allocated'] == True
    deallocate, _ = user.post(res=models.Deallocate, data=post_deallocate)
    assert deallocate['startTime'] == post_deallocate['startTime']
    assert deallocate['devices'][0]['id'] == device_id
    assert deallocate['devices'][0]['allocated'] == False
    res, _ = user.post(res=models.Deallocate, data=post_deallocate, status=422)
    assert res['code'] == 422
    assert res['type'] == 'ValidationError'


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_deallocate_bad_dates(user: UserClient):
    """Tests deallocate with bad date of start_time"""
    snapshot, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    device_id = snapshot['device']['id']
    delay = timedelta(days=30)
    future = datetime.now().replace(tzinfo=tzutc()) + delay
    post_deallocate = {"startTime": future, "devices": [device_id]}
    post_allocate = {
        "devices": [device_id],
        "description": "aaa",
        "startTime": "2020-11-01T02:00:00+00:00",
    }

    user.post(res=models.Allocate, data=post_allocate)
    res, _ = user.post(res=models.Deallocate, data=post_deallocate, status=422)
    assert res['code'] == 422
    assert res['type'] == 'ValidationError'


@pytest.mark.mvp
@pytest.mark.xfail(reason='Old functionality')
def test_trade_endpoint(user: UserClient, user2: UserClient):
    """Tests POST one simple Trade between 2 users of the system."""
    snapshot, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    device, _ = user.get(res=Device, item=snapshot['device']['id'])
    assert device['id'] == snapshot['device']['id']
    request_post = {
        'userTo': user2.user['email'],
        'price': 1.0,
        'date': "2020-12-01T02:00:00+00:00",
        'devices': [snapshot['device']['id']],
    }
    action, _ = user.post(res=models.Trade, data=request_post)

    with raises(JSONDecodeError):
        device1, _ = user.get(res=Device, item=device['id'])

    device2, _ = user2.get(res=Device, item=device['id'])
    assert device2['id'] == device['id']


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_trade_without_device(user: UserClient, user2: UserClient):
    """Test one offer with automatic confirmation and without user to"""
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)

    request_post = {
        'type': 'Trade',
        'userFromEmail': user.email,
        'userToEmail': user2.email,
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)

    trade = models.Trade.query.one()
    assert str(trade.lot.id) == lot['id']


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_offer_without_to(user: UserClient):
    """Test one offer with automatic confirmation and without user to"""
    snapshot, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    device = Device.query.filter_by(id=snapshot['device']['id']).one()
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=[('id', device.id)]
    )

    # check the owner of the device
    assert device.owner.email == user.email
    for c in device.components:
        assert c.owner.email == user.email

    request_post = {
        'type': 'Trade',
        'devices': [device.id],
        'userFromEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': False,
        'code': 'MAX',
    }
    user.post(res=models.Action, data=request_post)

    trade = models.Trade.query.one()
    assert device in trade.devices
    # assert trade.confirm_transfer
    users = [ac.user for ac in trade.acceptances]
    assert trade.user_to == device.owner
    assert request_post['code'].lower() in device.owner.email
    assert device.owner.active == False
    assert device.owner.phantom == True
    assert trade.user_to in users
    assert trade.user_from in users
    assert device.owner.email != user.email
    for c in device.components:
        assert c.owner.email != user.email

    # check if the user_from is owner of the devices
    request_post = {
        'type': 'Trade',
        'devices': [device.id],
        'userFromEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': False,
        'code': 'MAX',
    }
    user.post(res=models.Action, data=request_post, status=422)
    trade = models.Trade.query.one()

    # Check if the new phantom account is reused and not duplicated
    computer = file('1-device-with-components.snapshot')
    snapshot2, _ = user.post(computer, res=models.Snapshot)
    device2 = Device.query.filter_by(id=snapshot2['device']['id']).one()
    lot2 = Lot('MyLot2')
    lot2.owner_id = user.user['id']
    lot2.devices.add(device2)
    db.session.add(lot2)
    db.session.flush()
    request_post2 = {
        'type': 'Trade',
        'devices': [device2.id],
        'userFromEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot2.id,
        'confirms': False,
        'code': 'MAX',
    }
    user.post(res=models.Action, data=request_post2)
    assert User.query.filter_by(email=device.owner.email).count() == 1


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_offer_without_from(user: UserClient, user2: UserClient):
    """Test one offer without confirmation and without user from"""
    snapshot, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    lot = Lot('MyLot')
    lot.owner_id = user.user['id']
    device = Device.query.filter_by(id=snapshot['device']['id']).one()

    # check the owner of the device
    assert device.owner.email == user.email
    assert device.owner.email != user2.email

    lot.devices.add(device)
    db.session.add(lot)
    db.session.flush()
    request_post = {
        'type': 'Trade',
        'devices': [device.id],
        'userToEmail': user2.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot.id,
        'confirms': False,
        'code': 'MAX',
    }
    action, _ = user2.post(res=models.Action, data=request_post, status=422)

    request_post['userToEmail'] = user.email
    action, _ = user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()

    phantom_user = trade.user_from
    assert request_post['code'].lower() in phantom_user.email
    assert phantom_user.active == False
    assert phantom_user.phantom == True
    # assert trade.confirm_transfer

    users = [ac.user for ac in trade.acceptances]
    assert trade.user_to in users
    assert trade.user_from in users
    assert user.email in trade.devices[0].owner.email
    assert device.owner.email != user2.email
    assert device.owner.email == user.email


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_offer_without_users(user: UserClient):
    """Test one offer with doble confirmation"""
    user2 = User(email='baz@baz.cxm', password='baz')
    user2.individuals.add(Person(name='Tommy'))
    db.session.add(user2)
    db.session.commit()
    snapshot, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    lot = Lot('MyLot')
    lot.owner_id = user.user['id']
    device = Device.query.filter_by(id=snapshot['device']['id']).one()
    lot.devices.add(device)
    db.session.add(lot)
    db.session.flush()
    request_post = {
        'type': 'Trade',
        'devices': [device.id],
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot.id,
        'confirms': False,
        'code': 'MAX',
    }
    action, response = user.post(res=models.Action, data=request_post, status=422)
    txt = 'you need one user from or user to for to do a trade'
    assert txt in action['message']['_schema']


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_offer(user: UserClient):
    """Test one offer with doble confirmation"""
    user2 = User(email='baz@baz.cxm', password='baz')
    user2.individuals.add(Person(name='Tommy'))
    db.session.add(user2)
    db.session.commit()
    snapshot, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    lot = Lot('MyLot')
    lot.owner_id = user.user['id']
    device = Device.query.filter_by(id=snapshot['device']['id']).one()
    assert device.owner.email == user.email
    assert device.owner.email != user2.email
    lot.devices.add(device)
    db.session.add(lot)
    db.session.flush()
    request_post = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user.email,
        'userToEmail': user2.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot.id,
        'confirms': True,
    }

    action, _ = user.post(res=models.Action, data=request_post)
    # no there are transfer of devices
    assert device.owner.email == user.email
    assert device.owner.email != user2.email


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_offer_without_devices(user: UserClient):
    """Test one offer with doble confirmation"""
    user2 = User(email='baz@baz.cxm', password='baz')
    user2.individuals.add(Person(name='Tommy'))
    db.session.add(user2)
    db.session.commit()
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    request_post = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user.email,
        'userToEmail': user2.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    # no there are transfer of devices


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.auth_app_context.__name__)
def test_price_custom():
    computer = Desktop(
        serial_number='sn1',
        model='ml1',
        manufacturer='mr1',
        chassis=ComputerChassis.Docking,
    )
    price = models.Price(price=Decimal(25.25), currency=Currency.EUR)
    price.device = computer
    assert computer.price == price
    db.session.add(computer)
    db.session.commit()

    client = UserClient(app, 'foo@foo.com', 'foo', response_wrapper=app.response_class)
    client.login()
    p, _ = client.get(res=models.Action, item=str(price.id))
    assert p['device']['id'] == price.device.id == computer.id
    assert p['price'] == 25.25
    assert p['currency'] == Currency.EUR.name == 'EUR'

    c, _ = client.get(res=Device, item=computer.devicehub_id)
    assert c['price']['id'] == p['id']


@pytest.mark.mvp
def test_price_custom_client(user: UserClient):
    """As test_price_custom but creating the price through the API."""
    s = file('basic.snapshot')
    snapshot, _ = user.post(s, res=models.Snapshot)
    price, _ = user.post(
        {
            'type': 'Price',
            'price': 25,
            'currency': Currency.EUR.name,
            'device': snapshot['device']['id'],
        },
        res=models.Action,
    )
    assert 25 == price['price']
    assert Currency.EUR.name == price['currency']

    device, _ = user.get(res=Device, item=price['device']['devicehubID'])
    assert 25 == device['price']['price']


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.auth_app_context.__name__)
def test_erase_physical():
    erasure = models.ErasePhysical(
        device=HardDrive(serial_number='foo', manufacturer='bar', model='foo-bar'),
        method=enums.PhysicalErasureMethod.Disintegration,
    )
    db.session.add(erasure)
    db.session.commit()


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_endpoint_confirm(user: UserClient, user2: UserClient):
    """Check the normal creation and visualization of one confirmation trade"""
    snapshot, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    device_id = snapshot['device']['id']
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=[('id', device_id)]
    )

    request_post = {
        'type': 'Trade',
        'devices': [device_id],
        'userFromEmail': user.email,
        'userToEmail': user2.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()

    assert trade.devices[0].owner.email == user.email

    request_confirm = {'type': 'Confirm', 'action': trade.id, 'devices': [device_id]}

    user2.post(res=models.Action, data=request_confirm)
    user2.post(res=models.Action, data=request_confirm, status=422)
    assert len(trade.acceptances) == 2
    assert trade.devices[0].owner.email == user2.email


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_confirm_revoke(user: UserClient, user2: UserClient):
    """Check the normal revoke of one confirmation"""
    snapshot, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    device_id = snapshot['device']['id']
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=[('id', device_id)]
    )

    request_post = {
        'type': 'Trade',
        'devices': [device_id],
        'userFromEmail': user.email,
        'userToEmail': user2.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()
    device = trade.devices[0]

    request_confirm = {'type': 'Confirm', 'action': trade.id, 'devices': [device_id]}

    request_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [device_id],
    }

    # Normal confirmation
    user2.post(res=models.Action, data=request_confirm)

    # Normal revoke
    user2.post(res=models.Action, data=request_revoke)

    # You can to do one confirmation next of one revoke
    user2.post(res=models.Action, data=request_confirm)
    assert len(trade.acceptances) == 4
    assert device.trading(trade.lot) == "TradeConfirmed"


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_usecase_confirmation(user: UserClient, user2: UserClient):
    """Example of one usecase about confirmation"""
    # the pRp (manatest_usecase_confirmationger) creates a temporary lot
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    # The manager add 7 device into the lot
    snap1, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    snap2, _ = user.post(file('acer.happy.battery.snapshot'), res=models.Snapshot)
    snap3, _ = user.post(file('asus-1001pxd.snapshot'), res=models.Snapshot)
    snap4, _ = user.post(
        file('desktop-9644w8n-lenovo-0169622.snapshot'), res=models.Snapshot
    )
    snap5, _ = user.post(
        file('laptop-hp_255_g3_notebook-hewlett-packard-cnd52270fw.snapshot'),
        res=models.Snapshot,
    )
    snap6, _ = user.post(file('1-device-with-components.snapshot'), res=models.Snapshot)
    snap7, _ = user.post(file('asus-eee-1000h.snapshot.11'), res=models.Snapshot)
    snap8, _ = user.post(file('complete.export.snapshot'), res=models.Snapshot)
    snap9, _ = user.post(file('real-hp-quad-core.snapshot.11'), res=models.Snapshot)
    snap10, _ = user.post(file('david.lshw.snapshot'), res=models.Snapshot)

    devices = [
        ('id', snap1['device']['id']),
        ('id', snap2['device']['id']),
        ('id', snap3['device']['id']),
        ('id', snap4['device']['id']),
        ('id', snap5['device']['id']),
        ('id', snap6['device']['id']),
        ('id', snap7['device']['id']),
        ('id', snap8['device']['id']),
        ('id', snap9['device']['id']),
        ('id', snap10['device']['id']),
    ]
    lot, _ = user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[:7]
    )

    # the manager shares the temporary lot with the SCRAP as an incoming lot
    # for the SCRAP to confirm it
    request_post = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()
    # l_after, _ = user.get(res=Lot, item=lot['id'])

    # the SCRAP confirms 3 of the 10 devices in its outgoing lot
    request_confirm = {
        'type': 'Confirm',
        'action': trade.id,
        'devices': [
            snap1['device']['id'],
            snap2['device']['id'],
            snap3['device']['id'],
        ],
    }
    assert trade.devices[0].actions[-2].t == 'Trade'
    assert trade.devices[0].actions[-1].t == 'Confirm'
    assert trade.devices[0].actions[-1].user == trade.user_to

    user2.post(res=models.Action, data=request_confirm)
    assert trade.devices[0].actions[-1].t == 'Confirm'
    assert trade.devices[0].actions[-1].user == trade.user_from
    n_actions = len(trade.devices[0].actions)

    # check validation error
    request_confirm = {
        'type': 'Confirm',
        'action': trade.id,
        'devices': [snap10['device']['id']],
    }

    user2.post(res=models.Action, data=request_confirm, status=422)

    # The manager add 3 device more into the lot
    lot, _ = user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[7:]
    )

    assert trade.devices[-1].actions[-2].t == 'Trade'
    assert trade.devices[-1].actions[-1].t == 'Confirm'
    assert trade.devices[-1].actions[-1].user == trade.user_to
    assert len(trade.devices[0].actions) == n_actions

    # the SCRAP confirms the rest of devices
    request_confirm = {
        'type': 'Confirm',
        'action': trade.id,
        'devices': [
            snap4['device']['id'],
            snap5['device']['id'],
            snap6['device']['id'],
            snap7['device']['id'],
            snap8['device']['id'],
            snap9['device']['id'],
            snap10['device']['id'],
        ],
    }

    user2.post(res=models.Action, data=request_confirm)
    assert trade.devices[-1].actions[-3].t == 'Trade'
    assert trade.devices[-1].actions[-1].t == 'Confirm'
    assert trade.devices[-1].actions[-1].user == trade.user_from
    assert len(trade.devices[0].actions) == n_actions

    # The manager remove one device of the lot and automaticaly
    # is create one revoke action
    device_10 = trade.devices[-1]
    lot, _ = user.delete(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:], status=200
    )
    assert len(trade.lot.devices) == len(trade.devices) == 10
    assert device_10.actions[-1].t == 'Revoke'

    lot, _ = user.delete(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:], status=200
    )

    assert device_10.actions[-1].t == 'Revoke'

    # the SCRAP confirms the revoke action
    request_confirm_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [snap10['device']['id']],
    }

    user2.post(res=models.Action, data=request_confirm_revoke)
    assert device_10.actions[-1].t == 'Revoke'
    assert device_10.actions[-2].t == 'Revoke'
    # assert len(trade.lot.devices) == len(trade.devices) == 9
    # assert not device_10 in trade.devices

    # check validation error
    request_confirm_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [snap9['device']['id']],
    }

    # The manager add again device_10
    # assert len(trade.devices) == 9
    lot, _ = user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:]
    )

    assert device_10.actions[-1].t == 'Confirm'
    assert device_10 in trade.devices
    assert len(trade.devices) == 10

    # the SCRAP confirms the action trade for device_10
    request_reconfirm = {
        'type': 'Confirm',
        'action': trade.id,
        'devices': [snap10['device']['id']],
    }
    user2.post(res=models.Action, data=request_reconfirm)
    assert device_10.actions[-1].t == 'Confirm'
    assert device_10.actions[-1].user == trade.user_from
    assert device_10.actions[-2].t == 'Confirm'
    assert device_10.actions[-2].user == trade.user_to
    assert device_10.actions[-3].t == 'Revoke'
    # assert len(device_10.actions) == 13


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_confirmRevoke(user: UserClient, user2: UserClient):
    """Example of one usecase about confirmation"""
    # the pRp (manatest_usecase_confirmationger) creates a temporary lot
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    # The manager add 7 device into the lot
    snap1, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    snap2, _ = user.post(file('acer.happy.battery.snapshot'), res=models.Snapshot)
    snap3, _ = user.post(file('asus-1001pxd.snapshot'), res=models.Snapshot)
    snap4, _ = user.post(
        file('desktop-9644w8n-lenovo-0169622.snapshot'), res=models.Snapshot
    )
    snap5, _ = user.post(
        file('laptop-hp_255_g3_notebook-hewlett-packard-cnd52270fw.snapshot'),
        res=models.Snapshot,
    )
    snap6, _ = user.post(file('1-device-with-components.snapshot'), res=models.Snapshot)
    snap7, _ = user.post(file('asus-eee-1000h.snapshot.11'), res=models.Snapshot)
    snap8, _ = user.post(file('complete.export.snapshot'), res=models.Snapshot)
    snap9, _ = user.post(file('real-hp-quad-core.snapshot.11'), res=models.Snapshot)
    snap10, _ = user.post(file('david.lshw.snapshot'), res=models.Snapshot)

    devices = [
        ('id', snap1['device']['id']),
        ('id', snap2['device']['id']),
        ('id', snap3['device']['id']),
        ('id', snap4['device']['id']),
        ('id', snap5['device']['id']),
        ('id', snap6['device']['id']),
        ('id', snap7['device']['id']),
        ('id', snap8['device']['id']),
        ('id', snap9['device']['id']),
        ('id', snap10['device']['id']),
    ]
    lot, _ = user.post({}, res=Lot, item='{}/devices'.format(lot['id']), query=devices)

    # the manager shares the temporary lot with the SCRAP as an incoming lot
    # for the CRAP to confirm it
    request_post = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()

    # the SCRAP confirms all of devices
    request_confirm = {
        'type': 'Confirm',
        'action': trade.id,
        'devices': [
            snap1['device']['id'],
            snap2['device']['id'],
            snap3['device']['id'],
            snap4['device']['id'],
            snap5['device']['id'],
            snap6['device']['id'],
            snap7['device']['id'],
            snap8['device']['id'],
            snap9['device']['id'],
            snap10['device']['id'],
        ],
    }

    user2.post(res=models.Action, data=request_confirm)
    assert trade.devices[-1].actions[-3].t == 'Trade'
    assert trade.devices[-1].actions[-1].t == 'Confirm'
    assert trade.devices[-1].actions[-1].user == trade.user_from

    # The manager remove one device of the lot and automaticaly
    # is create one revoke action
    device_10 = trade.devices[-1]
    lot, _ = user.delete(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:], status=200
    )
    # assert len(trade.lot.devices) == len(trade.devices) == 9
    # assert not device_10 in trade.devices
    assert device_10.actions[-1].t == 'Revoke'

    lot, _ = user.delete(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:], status=200
    )

    assert device_10.actions[-1].t == 'Revoke'
    # assert device_10.actions[-2].t == 'Confirm'

    # The manager add again device_10
    # assert len(trade.devices) == 9
    lot, _ = user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:]
    )

    # assert device_10.actions[-1].t == 'Confirm'
    assert device_10 in trade.devices
    assert len(trade.devices) == 10

    # the SCRAP confirms the revoke action
    request_confirm_revoke = {
        'type': 'ConfirmRevoke',
        'action': device_10.actions[-2].id,
        'devices': [snap10['device']['id']],
    }

    # check validation error
    # user2.post(res=models.Action, data=request_confirm_revoke, status=422)

    # the SCRAP confirms the action trade for device_10
    # request_reconfirm = {
    # 'type': 'Confirm',
    # 'action': trade.id,
    # 'devices': [
    # snap10['device']['id']
    # ]
    # }
    # user2.post(res=models.Action, data=request_reconfirm)
    # assert device_10.actions[-1].t == 'Confirm'
    # assert device_10.actions[-1].user == trade.user_from
    # assert device_10.actions[-2].t == 'Confirm'
    # assert device_10.actions[-2].user == trade.user_to
    # assert device_10.actions[-3].t == 'Revoke'


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_trade_case1(user: UserClient, user2: UserClient):
    # the pRp (manatest_usecase_confirmationger) creates a temporary lot
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    # The manager add 7 device into the lot
    snap1, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    snap2, _ = user.post(file('acer.happy.battery.snapshot'), res=models.Snapshot)

    devices = [
        ('id', snap1['device']['id']),
        ('id', snap2['device']['id']),
    ]
    lot, _ = user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[:-1]
    )

    # the manager shares the temporary lot with the SCRAP as an incoming lot
    # for the CRAP to confirm it
    request_post = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()

    lot = trade.lot
    device = trade.devices[0]

    assert device.actions[-2].t == 'Trade'
    assert device.actions[-1].t == 'Confirm'
    assert device.actions[-1].user == trade.user_to

    user.delete(
        {}, res=Lot, item='{}/devices'.format(lot.id), query=devices[:-1], status=200
    )

    assert device not in trade.lot.devices
    assert device.trading(trade.lot) == 'RevokeConfirmed'
    assert device.actions[-2].t == 'Confirm'
    assert device.actions[-1].t == 'Revoke'
    assert device.actions[-1].user == trade.user_to


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_trade_case2(user: UserClient, user2: UserClient):
    # the pRp (manatest_usecase_confirmationger) creates a temporary lot
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    # The manager add 7 device into the lot
    snap1, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    snap2, _ = user.post(file('acer.happy.battery.snapshot'), res=models.Snapshot)

    devices = [
        ('id', snap1['device']['id']),
        ('id', snap2['device']['id']),
    ]
    lot, _ = user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[:-1]
    )

    # the manager shares the temporary lot with the SCRAP as an incoming lot
    # for the CRAP to confirm it
    request_post = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()

    lot, _ = user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:]
    )

    device1, device2 = trade.devices

    assert device1.actions[-2].t == 'Trade'
    assert device1.actions[-1].t == 'Confirm'
    assert device1.actions[-1].user == trade.user_to
    assert device2.actions[-2].t == 'Trade'
    assert device2.actions[-1].t == 'Confirm'
    assert device2.actions[-1].user == trade.user_to

    request_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [device1.id, device2.id],
    }

    # Normal revoke
    user.post(res=models.Action, data=request_revoke)

    assert device1.actions[-2].t == 'Confirm'
    assert device1.actions[-1].t == 'Revoke'
    assert device1.actions[-1].user == trade.user_to
    assert device2.actions[-2].t == 'Confirm'
    assert device2.actions[-1].t == 'Revoke'
    assert device2.actions[-1].user == trade.user_to
    assert device1.trading(trade.lot) == 'RevokeConfirmed'


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_trade_case3(user: UserClient, user2: UserClient):
    # the pRp (manatest_usecase_confirmationger) creates a temporary lot
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    snap1, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    snap2, _ = user2.post(file('acer.happy.battery.snapshot'), res=models.Snapshot)

    devices = [
        ('id', snap1['device']['id']),
        ('id', snap2['device']['id']),
    ]
    lot, _ = user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[:-1]
    )

    # the manager shares the temporary lot with the SCRAP as an incoming lot
    # for the CRAP to confirm it
    request_post = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()

    lot, _ = user2.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:]
    )

    device1, device2 = trade.devices

    assert device1.actions[-2].t == 'Trade'
    assert device1.actions[-1].t == 'Confirm'
    assert device1.actions[-1].user == trade.user_to
    assert device2.actions[-2].t == 'Trade'
    assert device2.actions[-1].t == 'Confirm'
    assert device2.actions[-1].user == trade.user_from

    lot, _ = user2.delete(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:], status=200
    )

    assert device2.actions[-2].t == 'Confirm'
    assert device2.actions[-1].t == 'Revoke'
    assert device2.actions[-1].user == trade.user_from
    assert device2.trading(trade.lot) == 'RevokeConfirmed'


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_trade_case4(user: UserClient, user2: UserClient):
    # the pRp (manatest_usecase_confirmationger) creates a temporary lot
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    # The manager add 7 device into the lot
    snap1, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    snap2, _ = user2.post(file('acer.happy.battery.snapshot'), res=models.Snapshot)

    devices = [
        ('id', snap1['device']['id']),
        ('id', snap2['device']['id']),
    ]
    lot1, _ = user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[:-1]
    )

    # the manager shares the temporary lot with the SCRAP as an incoming lot
    # for the CRAP to confirm it
    request_post = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()

    lot2, _ = user2.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:]
    )

    device1, device2 = trade.devices

    assert device1.actions[-2].t == 'Trade'
    assert device1.actions[-1].t == 'Confirm'
    assert device1.actions[-1].user == trade.user_to
    assert device2.actions[-2].t == 'Trade'
    assert device2.actions[-1].t == 'Confirm'
    assert device2.actions[-1].user == trade.user_from

    request_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [device2.id],
    }

    # Normal revoke
    user2.post(res=models.Action, data=request_revoke)

    assert device1.actions[-2].t == 'Trade'
    assert device1.actions[-1].t == 'Confirm'
    assert device1.actions[-1].user == trade.user_to
    assert device2.actions[-2].t == 'Confirm'
    assert device2.actions[-1].t == 'Revoke'
    assert device2.actions[-1].user == trade.user_from
    assert device2.trading(trade.lot) == 'RevokeConfirmed'


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_trade_case5(user: UserClient, user2: UserClient):
    # the pRp (manatest_usecase_confirmationger) creates a temporary lot
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    # The manager add 7 device into the lot
    snap1, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    snap2, _ = user.post(file('acer.happy.battery.snapshot'), res=models.Snapshot)

    devices = [
        ('id', snap1['device']['id']),
        ('id', snap2['device']['id']),
    ]
    lot, _ = user.post({}, res=Lot, item='{}/devices'.format(lot['id']), query=devices)

    # the manager shares the temporary lot with the SCRAP as an incoming lot
    # for the CRAP to confirm it
    request_post = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()

    device1, device2 = trade.devices

    assert device1.actions[-2].t == 'Trade'
    assert device1.actions[-1].t == 'Confirm'
    assert device1.actions[-1].user == trade.user_to
    assert device2.actions[-2].t == 'Trade'
    assert device2.actions[-1].t == 'Confirm'
    assert device2.actions[-1].user == trade.user_to

    lot, _ = user2.delete(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:], status=200
    )

    assert device2.actions[-2].t == 'Confirm'
    assert device2.actions[-1].t == 'Revoke'
    assert device2.actions[-1].user == trade.user_from

    request_confirm_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [device2.id],
    }

    # Normal revoke
    user.post(res=models.Action, data=request_confirm_revoke)

    assert device2.actions[-2].t == 'Revoke'
    assert device2.actions[-1].t == 'Revoke'
    assert device2.actions[-1].user == trade.user_to
    assert device2.trading(trade.lot) == 'RevokeConfirmed'


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_trade_case6(user: UserClient, user2: UserClient):
    # the pRp (manatest_usecase_confirmationger) creates a temporary lot
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    # The manager add 7 device into the lot
    snap1, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    snap2, _ = user2.post(file('acer.happy.battery.snapshot'), res=models.Snapshot)

    devices = [
        ('id', snap1['device']['id']),
        ('id', snap2['device']['id']),
    ]
    lot, _ = user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[:-1]
    )

    # the manager shares the temporary lot with the SCRAP as an incoming lot
    # for the CRAP to confirm it
    request_post = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()

    lot, _ = user2.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:]
    )

    device1, device2 = trade.devices

    assert device1.actions[-2].t == 'Trade'
    assert device1.actions[-1].t == 'Confirm'
    assert device1.actions[-1].user == trade.user_to
    assert device2.actions[-2].t == 'Trade'
    assert device2.actions[-1].t == 'Confirm'
    assert device2.actions[-1].user == trade.user_from

    lot, _ = user.delete(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:], status=200
    )

    assert device2.actions[-2].t == 'Confirm'
    assert device2.actions[-1].t == 'Revoke'
    assert device2.actions[-1].user == trade.user_to

    request_confirm_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [device2.id],
    }

    # Normal revoke
    user2.post(res=models.Action, data=request_confirm_revoke)

    assert device2.actions[-2].t == 'Revoke'
    assert device2.actions[-1].t == 'Revoke'
    assert device2.actions[-1].user == trade.user_from
    assert device2.trading(trade.lot) == 'RevokeConfirmed'


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_trade_case7(user: UserClient, user2: UserClient):
    # the pRp (manatest_usecase_confirmationger) creates a temporary lot
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    # The manager add 7 device into the lot
    snap1, _ = user.post(file('basic.snapshot'), res=models.Snapshot)

    devices = [('id', snap1['device']['id'])]
    lot, _ = user.post({}, res=Lot, item='{}/devices'.format(lot['id']), query=devices)

    # the manager shares the temporary lot with the SCRAP as an incoming lot
    # for the CRAP to confirm it
    request_post = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()
    device = trade.devices[0]

    request_confirm = {
        'type': 'Confirm',
        'action': trade.id,
        'devices': [device.id],
    }

    # Normal revoke
    user2.post(res=models.Action, data=request_confirm)
    assert device.trading(trade.lot) == 'TradeConfirmed'

    lot, _ = user.delete(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices, status=200
    )

    request_confirm_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [device.id],
    }

    user2.post(res=models.Action, data=request_confirm_revoke)

    assert device.actions[-1].t == 'Revoke'
    assert device.actions[-1].user == trade.user_from
    assert device.actions[-2].t == 'Revoke'
    assert device.actions[-2].user == trade.user_to
    assert device.actions[-3].t == 'Confirm'
    assert device.actions[-3].user == trade.user_from
    assert device.actions[-4].t == 'Confirm'
    assert device.actions[-4].user == trade.user_to
    assert device.actions[-5].t == 'Trade'
    assert device.actions[-5].author == trade.user_to
    assert device.trading(trade.lot) == 'RevokeConfirmed'


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_trade_case8(user: UserClient, user2: UserClient):
    # the pRp (manatest_usecase_confirmationger) creates a temporary lot
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    # The manager add 7 device into the lot
    snap1, _ = user.post(file('basic.snapshot'), res=models.Snapshot)

    devices = [('id', snap1['device']['id'])]
    lot, _ = user.post({}, res=Lot, item='{}/devices'.format(lot['id']), query=devices)

    # the manager shares the temporary lot with the SCRAP as an incoming lot
    # for the CRAP to confirm it
    request_post = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()
    device = trade.devices[0]

    request_confirm = {
        'type': 'Confirm',
        'action': trade.id,
        'devices': [device.id],
    }

    # Normal revoke
    user2.post(res=models.Action, data=request_confirm)
    assert device.trading(trade.lot) == 'TradeConfirmed'

    request_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [device.id],
    }

    # Normal revoke
    user.post(res=models.Action, data=request_revoke)

    request_confirm_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [device.id],
    }

    user2.post(res=models.Action, data=request_confirm_revoke)

    assert device.actions[-1].t == 'Revoke'
    assert device.actions[-1].user == trade.user_from
    assert device.actions[-2].t == 'Revoke'
    assert device.actions[-2].user == trade.user_to
    assert device.actions[-3].t == 'Confirm'
    assert device.actions[-3].user == trade.user_from
    assert device.actions[-4].t == 'Confirm'
    assert device.actions[-4].user == trade.user_to
    assert device.actions[-5].t == 'Trade'
    assert device.actions[-5].author == trade.user_to
    assert device.trading(trade.lot) == 'RevokeConfirmed'


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_trade_case9(user: UserClient, user2: UserClient):
    # the pRp (manatest_usecase_confirmationger) creates a temporary lot
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    # The manager add 7 device into the lot
    snap1, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    snap2, _ = user2.post(file('acer.happy.battery.snapshot'), res=models.Snapshot)

    devices = [('id', snap1['device']['id']), ('id', snap2['device']['id'])]
    lot, _ = user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[:-1]
    )

    # the manager shares the temporary lot with the SCRAP as an incoming lot
    # for the CRAP to confirm it
    request_post = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()

    lot, _ = user2.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:]
    )

    device1, device = trade.devices

    assert device.owner == trade.user_from

    request_confirm = {
        'type': 'Confirm',
        'action': trade.id,
        'devices': [device.id],
    }

    # Normal revoke
    user.post(res=models.Action, data=request_confirm)
    assert device.trading(trade.lot) == 'TradeConfirmed'

    assert device.owner == trade.user_to

    lot, _ = user2.delete(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:], status=200
    )

    request_confirm_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [device.id],
    }

    user.post(res=models.Action, data=request_confirm_revoke)

    assert device.owner == trade.user_from

    assert device.actions[-1].t == 'Revoke'
    assert device.actions[-1].user == trade.user_to
    assert device.actions[-2].t == 'Revoke'
    assert device.actions[-2].user == trade.user_from
    assert device.actions[-3].t == 'Confirm'
    assert device.actions[-3].user == trade.user_to
    assert device.actions[-4].t == 'Confirm'
    assert device.actions[-4].user == trade.user_from
    assert device.actions[-5].t == 'Trade'
    assert device.actions[-5].author == trade.user_to
    assert device.trading(trade.lot) == 'RevokeConfirmed'


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_trade_case10(user: UserClient, user2: UserClient):
    # the pRp (manatest_usecase_confirmationger) creates a temporary lot
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    # The manager add 7 device into the lot
    snap1, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    snap2, _ = user2.post(file('acer.happy.battery.snapshot'), res=models.Snapshot)

    devices = [('id', snap1['device']['id']), ('id', snap2['device']['id'])]
    lot, _ = user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[:-1]
    )

    # the manager shares the temporary lot with the SCRAP as an incoming lot
    # for the CRAP to confirm it
    request_post = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()

    lot, _ = user2.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:]
    )

    device1, device = trade.devices

    assert device.owner == trade.user_from
    # assert device.trading(trade.lot) == 'Confirm'

    request_confirm = {
        'type': 'Confirm',
        'action': trade.id,
        'devices': [device.id],
    }

    # Normal confirm
    user.post(res=models.Action, data=request_confirm)
    # assert device.trading(trade.lot) == 'TradeConfirmed'

    assert device.owner == trade.user_to

    request_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [device.id],
    }

    # Normal revoke
    user2.post(res=models.Action, data=request_revoke)
    assert device.trading(trade.lot) == 'Revoke'

    request_confirm_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [device.id],
    }

    user.post(res=models.Action, data=request_confirm_revoke)

    assert device.owner == trade.user_from
    assert device.actions[-1].t == 'Revoke'
    assert device.actions[-1].user == trade.user_to
    assert device.actions[-2].t == 'Revoke'
    assert device.actions[-2].user == trade.user_from
    assert device.actions[-3].t == 'Confirm'
    assert device.actions[-3].user == trade.user_to
    assert device.actions[-4].t == 'Confirm'
    assert device.actions[-4].user == trade.user_from
    assert device.actions[-5].t == 'Trade'
    assert device.actions[-5].author == trade.user_to
    assert device.trading(trade.lot) == 'RevokeConfirmed'


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_trade_case11(user: UserClient, user2: UserClient):
    # the pRp (manatest_usecase_confirmationger) creates a temporary lot
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    # The manager add 7 device into the lot
    snap1, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    snap2, _ = user.post(file('acer.happy.battery.snapshot'), res=models.Snapshot)

    devices = [('id', snap1['device']['id']), ('id', snap2['device']['id'])]
    lot, _ = user.post({}, res=Lot, item='{}/devices'.format(lot['id']), query=devices)

    # the manager shares the temporary lot with the SCRAP as an incoming lot
    # for the CRAP to confirm it
    request_post = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()

    device1, device = trade.devices
    assert device.trading(trade.lot) == 'Confirm'

    request_confirm = {
        'type': 'Confirm',
        'action': trade.id,
        'devices': [device.id],
    }

    user2.post(res=models.Action, data=request_confirm)
    assert device.trading(trade.lot) == 'TradeConfirmed'

    lot, _ = user2.delete(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:], status=200
    )
    assert device.trading(trade.lot) == 'Revoke'

    request_confirm_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [device.id],
    }

    user.post(res=models.Action, data=request_confirm_revoke)
    assert device.trading(trade.lot) == 'RevokeConfirmed'

    assert device.actions[-1].t == 'Revoke'
    assert device.actions[-1].user == trade.user_to
    assert device.actions[-2].t == 'Revoke'
    assert device.actions[-2].user == trade.user_from
    assert device.actions[-3].t == 'Confirm'
    assert device.actions[-3].user == trade.user_from
    assert device.actions[-4].t == 'Confirm'
    assert device.actions[-4].user == trade.user_to
    assert device.actions[-5].t == 'Trade'
    assert device.actions[-5].author == trade.user_to


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_trade_case12(user: UserClient, user2: UserClient):
    # the pRp (manatest_usecase_confirmationger) creates a temporary lot
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    # The manager add 7 device into the lot
    snap1, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    snap2, _ = user.post(file('acer.happy.battery.snapshot'), res=models.Snapshot)

    devices = [('id', snap1['device']['id']), ('id', snap2['device']['id'])]
    lot, _ = user.post({}, res=Lot, item='{}/devices'.format(lot['id']), query=devices)

    # the manager shares the temporary lot with the SCRAP as an incoming lot
    # for the CRAP to confirm it
    request_post = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()

    device1, device = trade.devices
    assert device.trading(trade.lot) == 'Confirm'

    # Normal confirm
    request_confirm = {
        'type': 'Confirm',
        'action': trade.id,
        'devices': [device.id],
    }

    user2.post(res=models.Action, data=request_confirm)
    assert device.trading(trade.lot) == 'TradeConfirmed'

    request_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [device.id],
    }

    # Normal revoke
    user2.post(res=models.Action, data=request_revoke)
    assert device.trading(trade.lot) == 'Revoke'

    request_confirm_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [device.id],
    }

    user.post(res=models.Action, data=request_confirm_revoke)
    assert device.trading(trade.lot) == 'RevokeConfirmed'

    assert device.actions[-1].t == 'Revoke'
    assert device.actions[-1].user == trade.user_to
    assert device.actions[-2].t == 'Revoke'
    assert device.actions[-2].user == trade.user_from
    assert device.actions[-3].t == 'Confirm'
    assert device.actions[-3].user == trade.user_from
    assert device.actions[-4].t == 'Confirm'
    assert device.actions[-4].user == trade.user_to
    assert device.actions[-5].t == 'Trade'
    assert device.actions[-5].author == trade.user_to


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_trade_case13(user: UserClient, user2: UserClient):
    # the pRp (manatest_usecase_confirmationger) creates a temporary lot
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    # The manager add 7 device into the lot
    snap1, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    snap2, _ = user2.post(file('acer.happy.battery.snapshot'), res=models.Snapshot)

    devices = [('id', snap1['device']['id']), ('id', snap2['device']['id'])]
    lot, _ = user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[:-1]
    )

    # the manager shares the temporary lot with the SCRAP as an incoming lot
    # for the CRAP to confirm it
    request_post = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()

    lot, _ = user2.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:]
    )

    device1, device = trade.devices
    assert device1.trading(trade.lot) == 'NeedConfirmation'
    assert device.trading(trade.lot) == 'Confirm'

    request_confirm = {
        'type': 'Confirm',
        'action': trade.id,
        'devices': [device.id],
    }

    user.post(res=models.Action, data=request_confirm)
    assert device1.trading(trade.lot) == 'Confirm'
    assert device.trading(trade.lot) == 'TradeConfirmed'

    lot, _ = user.delete(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:], status=200
    )
    assert device1.trading(trade.lot) == 'Confirm'
    assert device.trading(trade.lot) == 'Revoke'

    request_confirm_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [device.id],
    }

    user2.post(res=models.Action, data=request_confirm_revoke)
    assert device.trading(trade.lot) == 'RevokeConfirmed'

    assert device.actions[-1].t == 'Revoke'
    assert device.actions[-1].user == trade.user_from
    assert device.actions[-2].t == 'Revoke'
    assert device.actions[-2].user == trade.user_to
    assert device.actions[-3].t == 'Confirm'
    assert device.actions[-3].user == trade.user_to
    assert device.actions[-4].t == 'Confirm'
    assert device.actions[-4].user == trade.user_from
    assert device.actions[-5].t == 'Trade'
    assert device.actions[-5].author == trade.user_to


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_trade_case14(user: UserClient, user2: UserClient):
    # the pRp (manatest_usecase_confirmationger) creates a temporary lot
    lot, _ = user.post({'name': 'MyLot'}, res=Lot)
    # The manager add 7 device into the lot
    snap1, _ = user.post(file('basic.snapshot'), res=models.Snapshot)
    snap2, _ = user2.post(file('acer.happy.battery.snapshot'), res=models.Snapshot)

    devices = [('id', snap1['device']['id']), ('id', snap2['device']['id'])]
    lot, _ = user.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[:-1]
    )

    # the manager shares the temporary lot with the SCRAP as an incoming lot
    # for the CRAP to confirm it
    request_post = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lot['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_post)
    trade = models.Trade.query.one()

    lot, _ = user2.post(
        {}, res=Lot, item='{}/devices'.format(lot['id']), query=devices[-1:]
    )

    device1, device = trade.devices
    assert device1.trading(trade.lot) == 'NeedConfirmation'
    assert device.trading(trade.lot) == 'Confirm'

    # Normal confirm
    request_confirm = {
        'type': 'Confirm',
        'action': trade.id,
        'devices': [device.id],
    }

    user.post(res=models.Action, data=request_confirm)
    assert device.trading(trade.lot) == 'TradeConfirmed'

    request_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [device.id],
    }

    # Normal revoke
    user.post(res=models.Action, data=request_revoke)
    assert device.trading(trade.lot) == 'Revoke'

    request_confirm_revoke = {
        'type': 'Revoke',
        'action': trade.id,
        'devices': [device.id],
    }

    user2.post(res=models.Action, data=request_confirm_revoke)
    assert device.trading(trade.lot) == 'RevokeConfirmed'

    assert device.actions[-1].t == 'Revoke'
    assert device.actions[-1].user == trade.user_from
    assert device.actions[-2].t == 'Revoke'
    assert device.actions[-2].user == trade.user_to
    assert device.actions[-3].t == 'Confirm'
    assert device.actions[-3].user == trade.user_to
    assert device.actions[-4].t == 'Confirm'
    assert device.actions[-4].user == trade.user_from
    assert device.actions[-5].t == 'Trade'
    assert device.actions[-5].author == trade.user_to


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_action_web_erase(user: UserClient, client: Client):
    import hashlib

    from ereuse_devicehub.resources.documents import documents

    bfile = BytesIO(b'abc')
    hash3 = hashlib.sha3_256(bfile.read()).hexdigest()
    snap, _ = user.post(file('acer.happy.battery.snapshot'), res=models.Snapshot)
    request = {
        'type': 'DataWipe',
        'devices': [snap['device']['id']],
        'name': 'borrado universal',
        'severity': 'Info',
        'description': 'nada que describir',
        'url': 'http://www.google.com/',
        'documentId': '33',
        'endTime': '2021-07-07T22:00:00.000Z',
        'filename': 'Certificado de borrado1.pdf',
        'hash': hash3,
        'success': 1,
        'software': "Blanco",
    }

    user.post(res=models.Action, data=request)
    action = models.DataWipe.query.one()
    for dev in action.devices:
        assert action in dev.actions

    assert action.document.file_hash == request['hash']

    bfile = BytesIO(b'abc')
    response, _ = client.post(
        res=documents.DocumentDef.t,
        item='stamps/',
        content_type='multipart/form-data',
        accept='text/html',
        data={'docUpload': [(bfile, 'example.csv')]},
        status=200,
    )
    assert "alert alert-info" in response
    assert "100% coincidence." in response
    assert not "alert alert-danger" in response


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_moveOnDocument(user: UserClient, user2: UserClient):
    lotIn, _ = user.post({'name': 'MyLotIn'}, res=Lot)
    lotOut, _ = user.post({'name': 'MyLotOut'}, res=Lot)
    url = (
        'http://www.ereuse.org/apapaapaapaapaapaapaapaapaapaapapaapaapaapaapaapaapaapaapaapapaapaapaapaapaapaapaapaapaapaaaa',
    )
    request_post1 = {
        'filename': 'test.pdf',
        'hash': 'bbbbbbbb',
        'url': url,
        'weight': 150,
        'lot': lotIn['id'],
    }
    tradedocument_from, _ = user.post(res=TradeDocument, data=request_post1)
    id_hash = 'aaaaaaaaa'
    request_post2 = {
        'filename': 'test.pdf',
        'hash': id_hash,
        'url': url,
        'weight': 0,
        'lot': lotOut['id'],
    }
    tradedocument_to, _ = user.post(res=TradeDocument, data=request_post2)

    request_trade = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lotIn['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_trade)

    description = 'This is a good description'
    request_moveOn = {
        'type': 'MoveOnDocument',
        'weight': 15,
        'container_from': tradedocument_from['id'],
        'container_to': id_hash,
        'description': description,
    }
    doc, _ = user.post(res=models.Action, data=request_moveOn)

    assert doc['weight'] == request_moveOn['weight']
    assert doc['container_from']['id'] == tradedocument_from['id']
    assert doc['container_to']['id'] == tradedocument_to['id']

    mvs = models.MoveOnDocument.query.filter().first()
    trade_from = TradeDocument.query.filter_by(id=tradedocument_from['id']).one()
    trade_to = TradeDocument.query.filter_by(id=tradedocument_to['id']).one()
    assert trade_from in mvs.documents
    assert trade_to in mvs.documents
    assert description == mvs.description
    tradedocument_to, _ = user.post(res=TradeDocument, data=request_post2)
    user.post(res=models.Action, data=request_moveOn, status=422)


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_delete_devices(user: UserClient):
    """This action deactive one device and simulate than one devices is delete."""

    snap, _ = user.post(file('acer.happy.battery.snapshot'), res=models.Snapshot)
    request = {
        'type': 'Delete',
        'devices': [snap['device']['id']],
        'name': 'borrado universal',
        'severity': 'Info',
        'description': 'duplicity of devices',
        'endTime': '2021-07-07T22:00:00.000Z',
    }

    action, _ = user.post(res=models.Action, data=request)

    # Check get one device
    user.get(res=Device, item=snap['device']['devicehubID'], status=404)
    db_device = Device.query.filter_by(id=snap['device']['id']).one()

    action_delete = sorted(db_device.actions, key=lambda x: x.created)[-1]

    assert action_delete.t == 'Delete'
    assert str(action_delete.id) == action['id']
    assert db_device.active == False

    # Check use of filter from frontend
    url = '/devices/?filter={"type":["Computer"]}'

    devices, res = user.get(url, None)
    assert len(devices['items']) == 0


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_delete_devices_check_sync(user: UserClient):
    """This action deactive one device and simulate than one devices is delete."""

    file_snap1 = file('1-device-with-components.snapshot')
    file_snap2 = file('2-device-with-components.snapshot')
    snap, _ = user.post(file_snap1, res=models.Snapshot)
    request = {
        'type': 'Delete',
        'devices': [snap['device']['id']],
        'name': 'borrado universal',
        'severity': 'Info',
        'description': 'duplicity of devices',
        'endTime': '2021-07-07T22:00:00.000Z',
    }

    action, _ = user.post(res=models.Action, data=request)

    device1 = Device.query.filter_by(id=snap['device']['id']).one()

    snap2, _ = user.post(file_snap2, res=models.Snapshot)
    request2 = {
        'type': 'Delete',
        'devices': [snap2['device']['id']],
        'name': 'borrado universal',
        'severity': 'Info',
        'description': 'duplicity of devices',
        'endTime': '2021-07-07T22:00:00.000Z',
    }

    action2, _ = user.post(res=models.Action, data=request2)

    device2 = Device.query.filter_by(id=snap2['device']['id']).one()
    # check than device2 is an other device than device1
    assert device2.id != device1.id
    # check than device2 have the components of device1
    assert (
        len(
            [
                x
                for x in device2.components
                if device1.id
                in [y.device.id for y in x.actions if hasattr(y, 'device')]
            ]
        )
        == 1
    )


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_delete_devices_permitions(user: UserClient, user2: UserClient):
    """This action deactive one device and simulate than one devices is delete."""

    file_snap = file('1-device-with-components.snapshot')
    snap, _ = user.post(file_snap, res=models.Snapshot)
    device = Device.query.filter_by(id=snap['device']['id']).one()

    request = {
        'type': 'Delete',
        'devices': [snap['device']['id']],
        'name': 'borrado universal',
        'severity': 'Info',
        'description': 'duplicity of devices',
        'endTime': '2021-07-07T22:00:00.000Z',
    }
    action, _ = user2.post(res=models.Action, data=request, status=422)


@pytest.mark.mvp
@pytest.mark.usefixtures(conftest.app_context.__name__)
def test_moveOnDocument_bug168(user: UserClient, user2: UserClient):
    """If you use one moveOnDocument in a trade Document. Next you can not drop this document."""
    lotIn, _ = user.post({'name': 'MyLotIn'}, res=Lot)
    lotOut, _ = user.post({'name': 'MyLotOut'}, res=Lot)
    url = (
        'http://www.ereuse.org/apapaapaapaapaapaapaapaapaapaapapaapaapaapaapaapaapaapaapaapapaapaapaapaapaapaapaapaapaapaaaa',
    )
    request_post1 = {
        'filename': 'test.pdf',
        'hash': 'bbbbbbbb',
        'url': url,
        'weight': 150,
        'lot': lotIn['id'],
    }
    tradedocument_from, _ = user.post(res=TradeDocument, data=request_post1)
    id_hash = 'aaaaaaaaa'
    request_post2 = {
        'filename': 'test.pdf',
        'hash': id_hash,
        'url': url,
        'weight': 0,
        'lot': lotOut['id'],
    }
    tradedocument_to, _ = user.post(res=TradeDocument, data=request_post2)

    request_trade = {
        'type': 'Trade',
        'devices': [],
        'userFromEmail': user2.email,
        'userToEmail': user.email,
        'price': 10,
        'date': "2020-12-01T02:00:00+00:00",
        'lot': lotIn['id'],
        'confirms': True,
    }

    user.post(res=models.Action, data=request_trade)

    description = 'This is a good description'
    request_moveOn = {
        'type': 'MoveOnDocument',
        'weight': 4,
        'container_from': tradedocument_from['id'],
        'container_to': id_hash,
        'description': description,
    }
    doc, _ = user.post(res=models.Action, data=request_moveOn)
    trade = models.Trade.query.one()
    trade_document1 = TradeDocument.query.filter_by(id=tradedocument_from['id']).one()
    trade_document2 = TradeDocument.query.filter_by(id=tradedocument_to['id']).one()
    assert trade_document1.total_weight == 150.0
    assert trade_document2.total_weight == 4.0
    assert trade_document1.trading == 'Confirm'
    assert trade_document2.trading == None

    tradedocument, _ = user.delete(res=TradeDocument, item=tradedocument_to['id'])