def test_abstract_workload_remove():
    idx = 1
    mock_workload = mock.MagicMock(spec=AbstractWorkload)

    AbstractWorkload.remove(mock_workload, idx)

    mock_workload.__delitem__.assert_called_once_with(idx)
def test_abstract_workload_extend():
    sets = [{'reps': 10, 'weights': 100}, {'reps': 11, 'weights': 101}]
    mock_workload = mock.MagicMock(spec=AbstractWorkload)

    AbstractWorkload.extend(mock_workload, sets)

    mock_workload.append.assert_has_calls([mock.call(**s) for s in sets])
def test_abstract_workload_get_default(side_effect, default):
    mock_workload = mock.MagicMock(spec=AbstractWorkload)
    mock_workload.sets = mock.MagicMock()
    mock_workload.sets.get.side_effect = side_effect

    ret_val = AbstractWorkload.get(mock_workload, 1, default=default)

    assert ret_val == default
def test_abstract_workload_len():
    length = 2
    mock_workload = mock.MagicMock(spec=AbstractWorkload)
    mock_workload.sets = mock.MagicMock()
    mock_workload.sets.all().count.return_value = length

    ret_val = AbstractWorkload.__len__(mock_workload)

    assert ret_val == length
def test_abstract_workload_change_units(old_units, new_units):
    mock_workload = mock.MagicMock(spec=AbstractWorkload)
    mock_workload.units = old_units
    mock_workload.sets = mock.MagicMock()
    sets = [
        mock.MagicMock(spec=AbstractSet, units=old_units) for _ in range(3)
    ]
    mock_workload.sets.all.return_value = sets

    AbstractWorkload._change_units(mock_workload, new_units)

    mock_workload.units == new_units
    if old_units != new_units:
        for s in sets:
            s._change_units.assert_called_once_with(new_units)
    else:
        for s in sets:
            s._change_units.assert_not_called()
def test_abstract_workload_update(factory, units, new_movement, new_units):
    mock_workload = mock.MagicMock(spec=AbstractWorkload)
    movement = factory.build()
    mock_workload.movement = movement
    mock_workload.units = units
    if new_movement:
        new_movement = factory.build()

    AbstractWorkload.update(mock_workload,
                            movement=new_movement,
                            units=new_units)

    called_units = new_units or units
    mock_workload._change_units.assert_called_once_with(called_units)
    mock_workload.movement = new_movement or movement
    if new_movement is None and new_units is None:
        mock_workload.save.assert_not_called()
    else:
        mock_workload.save.assert_called_once()
def test_abstract_workload_get():
    idx = 3
    mock_workload = mock.MagicMock(spec=AbstractWorkload)
    mock_workload.sets = mock.MagicMock()
    mock_workload.sets.get.side_effect = lambda order=None: list(range(5))[
        order]

    ret_val = AbstractWorkload.get(mock_workload, idx)

    assert ret_val == idx
def test_abstract_workload_getitem():
    arg = 1
    gotten_item = 5
    mock_workload = mock.MagicMock(spec=AbstractWorkload)
    mock_workload.get.return_value = gotten_item

    ret_val = AbstractWorkload.__getitem__(mock_workload, arg)

    assert ret_val == 5
    mock_workload.get.assert_called_once_with(arg)
def test_abstract_workload_append(reps, weight, units, order):
    length = 2
    mock_workload = mock.MagicMock(spec=AbstractWorkload)
    mock_set = mock.MagicMock(spec=AbstractSet)
    mock_set.units = units
    mock_workload.units = units
    mock_workload._build_set.return_value = mock_set
    mock_workload.__len__.return_value = length

    AbstractWorkload.append(mock_workload,
                            reps,
                            weight,
                            units=units,
                            order=order)

    mock_workload._build_set.assert_called_once_with(
        reps, weight, units or mock_workload.units, order or length)
    mock_set._change_units.assert_called_once_with(mock_workload.units)
    mock_set.save.assert_called_once()
def test_abstract_workload_str(set_factory, movement_factory):
    sets = set_factory.build_batch(3)
    movement = movement_factory.build()
    mock_workload = mock.MagicMock(spec=AbstractWorkload)
    mock_workload.movement = movement
    mock_workload.sets = mock.MagicMock()
    mock_workload.sets.all.return_value = sets

    ret_val = AbstractWorkload.__str__(mock_workload)

    assert str(movement) in ret_val
    for s in sets:
        assert str(s) in ret_val
def test_abstract_workload_getitem_fail():
    mock_workload = mock.MagicMock(spec=AbstractWorkload)
    mock_workload.get.return_value = None

    with pytest.raises(KeyError):
        _ = AbstractWorkload.__getitem__(mock_workload, 1)
def test_abstract_workload_build_set():
    with pytest.raises(NotImplementedError):
        AbstractWorkload._build_set(mock.MagicMock(spec=AbstractWorkload), 10,
                                    100, KILOGRAMS, 0)
def test_abstract_workload_extend_fail(sets):
    mock_workload = mock.MagicMock(spec=AbstractWorkload)

    with pytest.raises(TypeError):
        AbstractWorkload.extend(mock_workload, sets)